ನಿರ್ದಿಷ್ಟ ಸೂಚ್ಯಂಕದಿಂದ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅರೇ ಅನ್ನು ನಕ್ಷೆ ಮಾಡಲು ಮಾನದಂಡವನ್ನು ಹೇಗೆ ಬಳಸುವುದು

ಸೂಚ್ಯಂಕ ಮತ್ತು ಷರತ್ತುಗಳ ಆಧಾರದ ಮೇಲೆ ಅರೇ ಮ್ಯಾಪಿಂಗ್‌ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವುದು

ಜೊತೆ ಕೆಲಸ ಮಾಡುವಾಗ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅರೇಗಳು, ನಿರ್ದಿಷ್ಟ ಸೂಚ್ಯಂಕದಿಂದ ಪ್ರಾರಂಭವಾಗುವ ಅಂಶಗಳ ಮೇಲೆ ಮಾತ್ರ ಕೇಂದ್ರೀಕರಿಸುವ ಮೂಲಕ ನೀವು ಕೆಲವೊಮ್ಮೆ ಡೇಟಾವನ್ನು ಪರಿವರ್ತಿಸಬೇಕಾಗಬಹುದು. ಮುಂತಾದ ವಿಧಾನಗಳನ್ನು ಬಳಸುವುದು Array.map() ಡೆವಲಪರ್‌ಗಳಿಗೆ ಅರೇಗಳ ಮೂಲಕ ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಪುನರಾವರ್ತನೆ ಮಾಡಲು ಮತ್ತು ರೂಪಾಂತರಗಳನ್ನು ಅನ್ವಯಿಸಲು ಅನುಮತಿಸುತ್ತದೆ. ಆದಾಗ್ಯೂ, ಪರಿಸ್ಥಿತಿಗಳ ಆಧಾರದ ಮೇಲೆ ಫಿಲ್ಟರಿಂಗ್ ಮಾಡುವಾಗ ಉತ್ತಮ ವಿಧಾನವನ್ನು ನಿರ್ಧರಿಸುವುದು ಕೆಲವು ಪ್ರಶ್ನೆಗಳಿಗೆ ಕಾರಣವಾಗಬಹುದು.

ಈ ಲೇಖನದಲ್ಲಿ, ನಿರ್ದಿಷ್ಟ ಸೂಚ್ಯಂಕದಿಂದ ಪ್ರಾರಂಭವಾಗುವ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಹೇಗೆ ಮ್ಯಾಪ್ ಮಾಡುವುದು ಮತ್ತು ವ್ಯಾಖ್ಯಾನಿಸಿದ ಆಧಾರದ ಮೇಲೆ ಅದರ ಅಂಶಗಳನ್ನು ಫಿಲ್ಟರ್ ಮಾಡುವುದು ಹೇಗೆ ಎಂದು ನಾವು ಅನ್ವೇಷಿಸುತ್ತೇವೆ. ಮಾನದಂಡ. ಉದಾಹರಣೆಗೆ, ಒಂದು ಸಾಮಾನ್ಯ ಅಗತ್ಯವೆಂದರೆ ನಿರ್ದಿಷ್ಟ ಮೌಲ್ಯಕ್ಕಿಂತ ಚಿಕ್ಕದಾದ ಸಂಖ್ಯೆಗಳ ಸೂಚಿಕೆಗಳನ್ನು ಹೊರತೆಗೆಯುವುದು. ದಕ್ಷತೆಯು ಮುಖ್ಯವಾದ ದೊಡ್ಡ ಡೇಟಾಸೆಟ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ ಈ ವಿಷಯವು ವಿಶೇಷವಾಗಿ ಮುಖ್ಯವಾಗಿದೆ.

ಒದಗಿಸಿದ ಕೋಡ್ ತುಣುಕನ್ನು ಬಳಸುವ ಪ್ರಯತ್ನವನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ ನಕ್ಷೆ() ಇದನ್ನು ಸಾಧಿಸಲು ಕಾರ್ಯ. ಆದಾಗ್ಯೂ, ಅಭಿವರ್ಧಕರು ಆಗಾಗ್ಗೆ ಆಶ್ಚರ್ಯ ಪಡುತ್ತಾರೆ Array.map() ಈ ಕಾರ್ಯಕ್ಕೆ ಅತ್ಯಂತ ಸೂಕ್ತವಾದ ಆಯ್ಕೆಯಾಗಿದೆ ಅಥವಾ ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿ ಪರ್ಯಾಯಗಳಿದ್ದರೆ. ಉತ್ತಮ ವಿಧಾನದ ಕಡೆಗೆ ನಿಮಗೆ ಮಾರ್ಗದರ್ಶನ ನೀಡಲು ನಾವು ಸಮಸ್ಯೆಯನ್ನು ವಿಶ್ಲೇಷಿಸುತ್ತೇವೆ.

ಈ ಚರ್ಚೆಯ ಅಂತ್ಯದ ವೇಳೆಗೆ, ಎರಡನ್ನೂ ಆಧರಿಸಿ ಅರೇಗಳನ್ನು ಹೇಗೆ ನಿರ್ವಹಿಸುವುದು ಎಂಬುದರ ಕುರಿತು ನೀವು ಉತ್ತಮ ತಿಳುವಳಿಕೆಯನ್ನು ಪಡೆಯುತ್ತೀರಿ ಸೂಚ್ಯಂಕ ಮತ್ತು ಮೌಲ್ಯಾಧಾರಿತ ಷರತ್ತುಗಳು. ವಿಶೇಷವಾಗಿ ಉತ್ತಮ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ನೀಡುವ ಪರ್ಯಾಯಗಳನ್ನು ನಾವು ನೋಡುತ್ತೇವೆ ದೊಡ್ಡ ಸರಣಿಗಳು.

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ನಿರ್ದಿಷ್ಟ ಸೂಚ್ಯಂಕದಿಂದ ಮ್ಯಾಪಿಂಗ್ ಅರೇಗಳಿಗೆ ಡೀಪ್ ಡೈವ್ ಮಾಡಿ

ಮೊದಲ ಸ್ಕ್ರಿಪ್ಟ್ ಬಳಕೆಯನ್ನು ತೋರಿಸುತ್ತದೆ Array.slice() ಜೊತೆ ಸಂಯೋಜಿಸಲಾಗಿದೆ Array.map(). ಈ ವಿಧಾನವು ಒಂದು ನಿರ್ದಿಷ್ಟ ಸೂಚ್ಯಂಕದಿಂದ ಪ್ರಾರಂಭವಾಗುವ ಮೂಲ ರಚನೆಯ ಭಾಗವನ್ನು ಹೊರತೆಗೆಯಲು ನಮಗೆ ಸಹಾಯ ಮಾಡುತ್ತದೆ ಮತ್ತು ನಂತರ ನಿರ್ದಿಷ್ಟ ಸ್ಥಿತಿಯನ್ನು ಆಧರಿಸಿ ಉಳಿದ ಅಂಶಗಳನ್ನು ನಕ್ಷೆ ಮಾಡುತ್ತದೆ. ಸ್ಲೈಸ್ ವಿಧಾನವು ಆಯ್ಕೆಮಾಡಿದ ಆರಂಭಿಕ ಸೂಚ್ಯಂಕದಿಂದ ಅಂಶಗಳನ್ನು ಮಾತ್ರ ಮುಂದಿನ ಪ್ರಕ್ರಿಯೆಗೆ ಪರಿಗಣಿಸಲಾಗುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ. ನಕ್ಷೆಯ ಕಾರ್ಯವು ಪ್ರತಿ ಮೌಲ್ಯವನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ ಮತ್ತು ಅದು 8 ಕ್ಕಿಂತ ಕಡಿಮೆ ಇರುವ ಮಾನದಂಡಗಳಿಗೆ ಹೊಂದಿಕೆಯಾದಲ್ಲಿ ಅದರ ಸೂಚ್ಯಂಕವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ, ಅಥವಾ -1 ಅದು ಮಾಡದಿದ್ದರೆ.

ಎರಡನೆಯ ಉದಾಹರಣೆಯು ಸಾಂಪ್ರದಾಯಿಕವನ್ನು ಬಳಸಿಕೊಂಡು ಹೆಚ್ಚು ಕಾರ್ಯಕ್ಷಮತೆ-ಆಪ್ಟಿಮೈಸ್ಡ್ ವಿಧಾನವನ್ನು ಕೇಂದ್ರೀಕರಿಸುತ್ತದೆ ಲೂಪ್ಗಾಗಿ. ಇಲ್ಲಿ, ಸ್ಕ್ರಿಪ್ಟ್ ಡೆವಲಪರ್‌ಗಳಿಗೆ ಅಪೇಕ್ಷಿತ ಸೂಚ್ಯಂಕದಿಂದ ಲೂಪ್ ಅನ್ನು ಹಸ್ತಚಾಲಿತವಾಗಿ ಪ್ರಾರಂಭಿಸುವ ಮೂಲಕ ಪುನರಾವರ್ತನೆಯ ಮೇಲೆ ಸಂಪೂರ್ಣ ನಿಯಂತ್ರಣವನ್ನು ನೀಡುತ್ತದೆ. ಈ ವಿಧಾನವು ನಕ್ಷೆ ಮತ್ತು ಫಿಲ್ಟರ್‌ನಂತಹ ಕ್ರಿಯಾತ್ಮಕ ವಿಧಾನಗಳಿಗೆ ಸಂಬಂಧಿಸಿದ ಹೆಚ್ಚುವರಿ ಓವರ್‌ಹೆಡ್ ಅನ್ನು ತಪ್ಪಿಸುತ್ತದೆ. ಪ್ರತಿ ಮಾನ್ಯವಾದ ಸೂಚ್ಯಂಕವನ್ನು ನೇರವಾಗಿ ಫಲಿತಾಂಶಗಳ ಶ್ರೇಣಿಗೆ ತಳ್ಳಲಾಗುತ್ತದೆ. ದೊಡ್ಡ ಅರೇಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ ಈ ವಿಧಾನದ ಪ್ರಯೋಜನವು ಸ್ಪಷ್ಟವಾಗುತ್ತದೆ, ಅಲ್ಲಿ ಕಾರ್ಯದ ಕರೆಗಳನ್ನು ಕಡಿಮೆ ಮಾಡುವುದರಿಂದ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಗಮನಾರ್ಹವಾಗಿ ಸುಧಾರಿಸಬಹುದು.

ಮೂರನೆಯ ಪರಿಹಾರವು ಕ್ರಿಯಾತ್ಮಕ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಪರ್ಯಾಯವನ್ನು ಒದಗಿಸುತ್ತದೆ Array.reduce(). ಈ ವಿಧಾನವು ಒಂದೇ ಶ್ರೇಣಿಯಲ್ಲಿ ಮಾನದಂಡಗಳನ್ನು ಪೂರೈಸುವ ಸೂಚ್ಯಂಕಗಳನ್ನು ಸಂಗ್ರಹಿಸುತ್ತದೆ, ಅದೇ ಫಲಿತಾಂಶವನ್ನು ಸಾಧಿಸಲು ಸಂಕ್ಷಿಪ್ತ ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತದೆ. ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಸೂಚ್ಯಂಕದಿಂದ ಪ್ರಾರಂಭವಾಗುವ ಪ್ರತಿಯೊಂದು ಅಂಶದ ಮೇಲೆ ಕಡಿತ ಕಾರ್ಯವು ಪುನರಾವರ್ತನೆಯಾಗುತ್ತದೆ ಮತ್ತು ಅಂಶವು ಸ್ಥಿತಿಯನ್ನು ಪೂರೈಸಿದರೆ, ಅದು ಶೇಖರಣಾ ರಚನೆಗೆ ಸೂಚ್ಯಂಕವನ್ನು ಸೇರಿಸುತ್ತದೆ. ಒಂದೇ ಪಾಸ್‌ನಲ್ಲಿ ಫಿಲ್ಟರಿಂಗ್ ಮತ್ತು ಕ್ರೋಢೀಕರಣ ಎರಡೂ ಅಗತ್ಯವಿರುವ ಸಂಕೀರ್ಣ ರೂಪಾಂತರಗಳಿಗೆ ಕಡಿಮೆ ವಿಧಾನವು ವಿಶೇಷವಾಗಿ ಉಪಯುಕ್ತವಾಗಿದೆ.

ಕೊನೆಯದಾಗಿ, ಈ ಪರಿಹಾರಗಳನ್ನು ಮೌಲ್ಯೀಕರಿಸಲು ಘಟಕ ಪರೀಕ್ಷೆಯು ನಿರ್ಣಾಯಕವಾಗಿದೆ, ವಿಶೇಷವಾಗಿ ರಚನೆಯ ಗಾತ್ರವು ಬೆಳೆದಾಗ ಅಥವಾ ಪರಿಸ್ಥಿತಿಗಳು ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ಬದಲಾದಾಗ. ಉದಾಹರಣೆ ಬಳಸುತ್ತದೆ ಜೆಸ್ಟ್ ಸ್ವಯಂಚಾಲಿತ ಪರೀಕ್ಷೆಗಳನ್ನು ನಡೆಸಲು ಫ್ರೇಮ್‌ವರ್ಕ್, ಪ್ರತಿಯೊಂದು ವಿಧಾನವು ವಿವಿಧ ಪ್ರಕರಣಗಳಿಗೆ ಸರಿಯಾದ ಔಟ್‌ಪುಟ್ ಅನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ. ಪರೀಕ್ಷೆಯು ಅಂಚಿನ ಪ್ರಕರಣಗಳನ್ನು ಗುರುತಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ ಮತ್ತು ಕೋಡ್ ವಿಭಿನ್ನ ಸನ್ನಿವೇಶಗಳಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬ ವಿಶ್ವಾಸವನ್ನು ನೀಡುತ್ತದೆ. ಪ್ರತಿ ಯುನಿಟ್ ಪರೀಕ್ಷೆಯು ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳಿಂದ ಹಿಂತಿರುಗಿಸಲಾದ ಸೂಚ್ಯಂಕಗಳು ನಿರೀಕ್ಷಿತ ಔಟ್‌ಪುಟ್‌ಗೆ ಹೊಂದಿಕೆಯಾಗುತ್ತದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ. ಈ ಸಮಗ್ರ ವಿಧಾನವು ಆಯ್ಕೆ ಮಾಡಿದ ವಿಧಾನವನ್ನು ಲೆಕ್ಕಿಸದೆಯೇ ಕಾರ್ಯಕ್ಷಮತೆ ಮತ್ತು ಸರಿಯಾಗಿರುವುದನ್ನು ಸಾಧಿಸುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ.

// Approach 1: Using Array.slice() and Array.map() for Partial Mapping
const array = [4, 2, 8, 3, 4, 6];
const startIndex = 1;  // Starting index for filtering
const result = array.slice(startIndex).map((x, i) => (x < 8 ? i + startIndex : -1))
                .filter(index => index !== -1);
console.log(result);  // Output: [1, 3, 4, 5]
// This method uses slice() to extract the subarray from index 1
// and map() to find indexes of elements meeting the criteria.

// Approach 2: Using a for loop for better control and optimization
const array = [4, 2, 8, 3, 4, 6];
const startIndex = 1;
const result = [];
for (let i = startIndex; i < array.length; i++) {
    if (array[i] < 8) result.push(i);
}
console.log(result);  // Output: [1, 3, 4, 5]
// This approach provides better performance with large arrays
// by avoiding the overhead of map() and filter().

// Approach 3: Functional approach using Array.reduce()
const array = [4, 2, 8, 3, 4, 6];
const startIndex = 1;
const result = array.reduce((acc, val, i) => {
    if (i >= startIndex && val < 8) acc.push(i);
    return acc;
}, []);
console.log(result);  // Output: [1, 3, 4, 5]
// Array.reduce() offers a concise and functional way to collect
// the indexes matching the criteria without additional filtering.

// Unit tests for all three approaches using Jest
const { test, expect } = require('@jest/globals');
const array = [4, 2, 8, 3, 4, 6];

test('Approach 1: Slice and Map', () => {
    const result = array.slice(1).map((x, i) => (x < 8 ? i + 1 : -1)).filter(i => i !== -1);
    expect(result).toEqual([1, 3, 4, 5]);
});

test('Approach 2: For Loop', () => {
    const result = [];
    for (let i = 1; i < array.length; i++) {
        if (array[i] < 8) result.push(i);
    }
    expect(result).toEqual([1, 3, 4, 5]);
});

test('Approach 3: Reduce', () => {
    const result = array.reduce((acc, val, i) => {
        if (i >= 1 && val < 8) acc.push(i);
        return acc;
    }, []);
    expect(result).toEqual([1, 3, 4, 5]);
});

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಸುಧಾರಿತ ಅರೇ ಮ್ಯಾಪಿಂಗ್ ತಂತ್ರಗಳನ್ನು ಅನ್ವೇಷಿಸಲಾಗುತ್ತಿದೆ

ಬಳಕೆಗೆ ಮೀರಿದ ಆಸಕ್ತಿದಾಯಕ ವಿಧಾನ Array.map() ಅಥವಾ ಲೂಪ್ಗಳಿಗಾಗಿ ಹತೋಟಿ ಹೊಂದಿದೆ Array.findIndex() ಪರಿಸ್ಥಿತಿಗಳ ಆಧಾರದ ಮೇಲೆ ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ಅಂಶಗಳನ್ನು ಪತ್ತೆ ಮಾಡುವ ವಿಧಾನ. ಈ ವಿಧಾನವು ಒಂದು ನಿರ್ದಿಷ್ಟ ಸ್ಥಿತಿಯನ್ನು ಪೂರೈಸುವ ಮೊದಲ ಸೂಚ್ಯಂಕವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ, ನೀವು ರಚನೆಯನ್ನು ಮ್ಯಾಪ್ ಮಾಡಬೇಕಾದಾಗ ಇದು ಉಪಯುಕ್ತವಾಗಿಸುತ್ತದೆ ಆದರೆ ಹೊಂದಾಣಿಕೆಯ ಅಂಶ ಕಂಡುಬಂದ ತಕ್ಷಣ ನಿಲ್ಲಿಸುತ್ತದೆ. ಇದು ಸಂಪೂರ್ಣ ರಚನೆಯ ಮೂಲಕ ಪುನರಾವರ್ತನೆಯಿಂದ ಸ್ವಲ್ಪ ಭಿನ್ನವಾಗಿದ್ದರೂ, ನಿರ್ದಿಷ್ಟ ಬಳಕೆಯ ಸಂದರ್ಭಗಳಿಗೆ ಉತ್ತಮವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುವ ಪರ್ಯಾಯವನ್ನು ನೀಡುತ್ತದೆ, ವಿಶೇಷವಾಗಿ ಮೊದಲ ಹೊಂದಾಣಿಕೆಯ ಸೂಚ್ಯಂಕ ಮಾತ್ರ ಅಗತ್ಯವಿದ್ದಾಗ.

ಓದುವಿಕೆಯನ್ನು ಸುಧಾರಿಸಲು ಮತ್ತೊಂದು ಪರ್ಯಾಯವಾಗಿದೆ Array.flatMap(). ಮ್ಯಾಪಿಂಗ್ ತರ್ಕವು ಒಂದೇ ಇನ್‌ಪುಟ್‌ಗಾಗಿ ಬಹು ಔಟ್‌ಪುಟ್‌ಗಳನ್ನು ರಚಿಸುವುದನ್ನು ಒಳಗೊಂಡಿದ್ದರೆ ಅಥವಾ ನೀವು ನೆಸ್ಟೆಡ್ ಫಲಿತಾಂಶಗಳನ್ನು ಒಂದು ಆಯಾಮದ ಅರೇಗಳಾಗಿ ಚಪ್ಪಟೆಗೊಳಿಸಬೇಕಾದರೆ ಈ ವಿಧಾನವು ವಿಶೇಷವಾಗಿ ಸಹಾಯಕವಾಗಿರುತ್ತದೆ. ಮಾನದಂಡಕ್ಕೆ ವಿರುದ್ಧವಾಗಿ ನಕ್ಷೆ(), ಅದೇ ಉದ್ದದ ಶ್ರೇಣಿಯನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ, ಫ್ಲಾಟ್ ಮ್ಯಾಪ್() ಒಂದೇ ಪಾಸ್‌ನಲ್ಲಿ ಮ್ಯಾಪಿಂಗ್ ಮತ್ತು ಚಪ್ಪಟೆ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಸಂಯೋಜಿಸುತ್ತದೆ. ಇದು ಸಾಮಾನ್ಯವಾಗಿ ಬಳಸಲ್ಪಡದಿದ್ದರೂ, ಇದು ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಹೆಚ್ಚು ಸಂಕೀರ್ಣ ಸನ್ನಿವೇಶಗಳಲ್ಲಿ ಸ್ಟ್ರೀಮ್‌ಲೈನ್ ಮಾಡಬಹುದು.

ಅಂತಿಮವಾಗಿ, ಕಾರ್ಯಕ್ಷಮತೆಯು ಒಂದು ಪ್ರಮುಖ ಕಾಳಜಿಯಾಗಿದ್ದರೆ, ಹೈಬ್ರಿಡ್ ವಿಧಾನವನ್ನು ಬಳಸುವುದು ಪ್ರತಿ () ಸ್ಥಿತಿ-ಆಧಾರಿತ ಪುಶ್ ತರ್ಕದೊಂದಿಗೆ ಸಂಯೋಜಿಸಲ್ಪಟ್ಟ ಪುನರಾವರ್ತನೆಗಾಗಿ ವೇಗ ಮತ್ತು ಸರಳತೆ ಎರಡನ್ನೂ ನೀಡುತ್ತದೆ. ಇದು ಅನಗತ್ಯ ಕಾರ್ಯ ಕರೆಗಳನ್ನು ನಿವಾರಿಸುತ್ತದೆ ಮತ್ತು ನಿಮ್ಮ ತರ್ಕವನ್ನು ಸರಳವಾಗಿರಿಸುತ್ತದೆ. ಅಂದಿನಿಂದ ಪ್ರತಿ () ಹೊಸ ರಚನೆಯನ್ನು ಹಿಂತಿರುಗಿಸುವುದಿಲ್ಲ, ಗುರಿಯು ಅಡ್ಡ ಪರಿಣಾಮಗಳಾಗಿದ್ದಾಗ ಅದು ಸೂಕ್ತವಾಗಿದೆ (ಬಾಹ್ಯ ರಚನೆಗೆ ಮೌಲ್ಯಗಳನ್ನು ಸೇರಿಸುವುದು). ಈ ಸಂಯೋಜನೆಯು ಕೋಡ್ ಸ್ಪಷ್ಟತೆಯನ್ನು ಕಾಪಾಡಿಕೊಳ್ಳುವಾಗ ಹೆಚ್ಚಿನ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಖಾತ್ರಿಗೊಳಿಸುತ್ತದೆ, ವಿಶೇಷವಾಗಿ ದೊಡ್ಡ ಡೇಟಾಸೆಟ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ.