C++ ಚೈನ್ಡ್ ಮೆಥಡ್ ಕರೆಗಳನ್ನು ಕ್ಲಾಂಗ್-ಫಾರ್ಮ್ಯಾಟ್ ಇಂಡೆಂಟೇಶನ್‌ನೊಂದಿಗೆ ಹೇಗೆ ಜೋಡಿಸುವುದು

ಪರಿಪೂರ್ಣ ಇಂಡೆಂಟೇಶನ್‌ಗಾಗಿ ಮಾಸ್ಟರಿಂಗ್ ಕ್ಲಾಂಗ್-ಫಾರ್ಮ್ಯಾಟ್

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

ನೀವು ಬಿಲ್ಡರ್ ಮಾದರಿಯೊಂದಿಗೆ ವಸ್ತುವನ್ನು ನಿರ್ಮಿಸುತ್ತಿದ್ದೀರಿ ಎಂದು ಕಲ್ಪಿಸಿಕೊಳ್ಳಿ. ನೀವು ಈ ರೀತಿಯ ಅಚ್ಚುಕಟ್ಟಾದ ಔಟ್‌ಪುಟ್ ಅನ್ನು ಬಯಸುತ್ತೀರಿ:

ಸ್ವಯಂ ಫೂ = ಫೂಬಿಲ್ಡರ್()
.ಏನಾದರೂ()
.ಬೇರೆಯೊಂದಿಗೆ()
.ಬಿಲ್ಡ್();

ಆದರೆ ಕ್ಲಾಂಗ್-ಫಾರ್ಮ್ಯಾಟ್ ನಿಮ್ಮ ವಿಧಾನಗಳನ್ನು ಬಲಕ್ಕೆ ತಳ್ಳಲು ಒತ್ತಾಯಿಸುತ್ತದೆ, ಕ್ಲೀನ್ ಕೋಡ್ ಅನ್ನು ವಿಸ್ತರಿಸಿದ ಅವ್ಯವಸ್ಥೆಯಾಗಿ ಪರಿವರ್ತಿಸುತ್ತದೆ. ಇದ್ದಕ್ಕಿದ್ದಂತೆ, ನಿಮ್ಮ ಒಮ್ಮೆ-ಸಂಘಟಿತ ಸಾಲುಗಳು ಅಸಮಂಜಸವಾಗಿ ಕಾಣುತ್ತವೆ ಮತ್ತು ದೃಶ್ಯ ಹರಿವು ಮುರಿದುಹೋಗಿದೆ. ಹತಾಶೆ, ಅಲ್ಲವೇ? 🤯

API ಸೇವೆಯನ್ನು ರಿಫ್ಯಾಕ್ಟರಿಂಗ್ ಮಾಡುವಾಗ ಈ ಸಮಸ್ಯೆಯನ್ನು ಎದುರಿಸಿದ್ದು ನನಗೆ ನೆನಪಿದೆ. ನನ್ನ ಪರಿಪೂರ್ಣವಾಗಿ ಜೋಡಿಸಲಾದ ವಿಧಾನದ ಕರೆಗಳು ಮೆಟ್ಟಿಲನ್ನು ಹೋಲುವ ಯಾವುದೋ ಆಗಿ ಮಾರ್ಪಟ್ಟಿವೆ-ಪ್ರತಿ ರೇಖೆಯು ಹೆಚ್ಚು ಬಲಕ್ಕೆ ತಳ್ಳಲ್ಪಟ್ಟಿದೆ. ಇದು ಕೋಡ್ ವಿಮರ್ಶೆಗಳನ್ನು ಕಠಿಣಗೊಳಿಸಿತು ಮತ್ತು ನನ್ನ ಕಣ್ಣುಗಳು ದಣಿದವು. ಈ ಲೇಖನದಲ್ಲಿ, ಚೈನ್ಡ್ ಕರೆಗಳಿಗಾಗಿ ಕ್ಲಾಂಗ್-ಫಾರ್ಮ್ಯಾಟ್ ಇಂಡೆಂಟೇಶನ್ ಮೇಲೆ ನಿಯಂತ್ರಣವನ್ನು ಮರಳಿ ಪಡೆಯಲು ನಾನು ಪ್ರಾಯೋಗಿಕ ಒಳನೋಟಗಳನ್ನು ಹಂಚಿಕೊಳ್ಳುತ್ತೇನೆ ಆದ್ದರಿಂದ ನಿಮ್ಮ ಕೋಡ್ ಸೊಗಸಾದ ಮತ್ತು ಓದಬಲ್ಲ ಎರಡೂ ಆಗಿರುತ್ತದೆ. 🛠️

# Step 1: Create a .clang-format file in your project root
# Step 2: Add the following configuration to control indentation
BasedOnStyle: Google
ContinuationIndentWidth: 4
AlignAfterOpenBracket: false
AllowShortFunctionsOnASingleLine: Empty
BreakBeforeBraces: Attach
# Align method calls relative to the previous line
ColumnLimit: 0 # Disables column wrapping
# Save and format your code

// Use clang-format directives to skip specific code regions
auto foo = FooBuilder()
    // clang-format off
    .WithSomething()
    .WithSomethingElse()
    .Build();
    // clang-format on
// clang-format will ignore indentation inside the marked section
// Useful for one-off adjustments without changing global settings
// Combine with other tools for consistency

import re
# Python script to reformat chained method calls
def adjust_indentation(input_file, output_file):
    with open(input_file, 'r') as f:
        lines = f.readlines()
    with open(output_file, 'w') as f_out:
        for line in lines:
            if re.search(r'^\s*\..*', line):
                f_out.write('    ' + line.strip() + '\n')
            else:
                f_out.write(line)
# Usage: adjust_indentation('input.cpp', 'output.cpp')

#include <gtest/gtest.h>
// Example function to validate chaining format
TEST(IndentationTest, ChainedMethods) {
    std::string expected =
        "auto foo = FooBuilder()\n"
        "    .WithSomething()\n"
        "    .WithSomethingElse()\n"
        "    .Build();";
    std::string actual = FooBuilder()
        .WithSomething()
        .WithSomethingElse()
        .Build();
    ASSERT_EQ(expected, actual);
}

ನಿಖರವಾದ ವಿಧಾನ ಚೈನಿಂಗ್‌ಗಾಗಿ ಫೈನ್-ಟ್ಯೂನಿಂಗ್ ಕ್ಲಾಂಗ್-ಫಾರ್ಮ್ಯಾಟ್

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

ರಚಿಸುವುದನ್ನು ಒಳಗೊಂಡಿರುವ ಮೊದಲ ಪರಿಹಾರವು a .ಕ್ಲಾಂಗ್-ಫಾರ್ಮ್ಯಾಟ್ ಕಡತ. ಈ ಫೈಲ್ ಡೆವಲಪರ್‌ಗಳಿಗೆ ತಮ್ಮ C++ ಪ್ರಾಜೆಕ್ಟ್‌ಗಳಿಗಾಗಿ ಫಾರ್ಮ್ಯಾಟಿಂಗ್ ನಿಯಮಗಳನ್ನು ಕಸ್ಟಮೈಸ್ ಮಾಡಲು ಅನುಮತಿಸುತ್ತದೆ. ಪ್ರಮುಖ ಸೆಟ್ಟಿಂಗ್‌ಗಳು ಸೇರಿವೆ ContinuationIndentWidth, ಇದು ಸಾಲಿನ ಮುಂದುವರಿಕೆಗಳಿಗಾಗಿ ಸ್ಥಳಗಳ ಸಂಖ್ಯೆಯನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತದೆ, ಮತ್ತು ಅಲೈನ್ಆಫ್ಟರ್ ಓಪನ್ಬ್ರಾಕೆಟ್, ಇದು ಬ್ರಾಕೆಟ್‌ಗಳ ನಂತರ ಅನಗತ್ಯವಾಗಿ ಕೋಡ್ ಅನ್ನು ಜೋಡಿಸುವುದರಿಂದ ಕ್ಲಾಂಗ್-ಫಾರ್ಮ್ಯಾಟ್ ಅನ್ನು ತಡೆಯುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ಸೆಟ್ಟಿಂಗ್ ಕಾಲಮ್‌ಮಿತಿ: 0 ಲೈನ್ ಬ್ರೇಕಿಂಗ್ ಅನ್ನು ನಿಷ್ಕ್ರಿಯಗೊಳಿಸುತ್ತದೆ, ಚೈನ್ಡ್ ವಿಧಾನಗಳು ಸರಿಯಾಗಿ ಜೋಡಿಸಲ್ಪಟ್ಟಿರುತ್ತವೆ ಮತ್ತು ದೃಷ್ಟಿಗೆ ಆಕರ್ಷಕವಾಗಿರುತ್ತವೆ.

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

ಅಂತಿಮವಾಗಿ, ಕ್ಲಾಂಗ್-ಫಾರ್ಮ್ಯಾಟ್ ಅನ್ನು ರನ್ ಮಾಡಿದ ನಂತರ ಪ್ರಕ್ರಿಯೆಯ ನಂತರದ ಫಾರ್ಮ್ಯಾಟಿಂಗ್ ಸಮಸ್ಯೆಗಳಿಗೆ ನಾವು ಪೈಥಾನ್ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಪರಿಚಯಿಸಿದ್ದೇವೆ. ಈ ಸ್ಕ್ರಿಪ್ಟ್ ಚೈನ್ಡ್ ಮೆಥಡ್ ಕರೆಗಳಿಗಾಗಿ ಸ್ಕ್ಯಾನ್ ಮಾಡುತ್ತದೆ ಮತ್ತು ಹಿಂದಿನ ಸಾಲಿಗೆ ಸಂಬಂಧಿಸಿದಂತೆ ಸ್ಪೇಸ್‌ಗಳನ್ನು ಸೇರಿಸುವ ಮೂಲಕ ಅವುಗಳ ಇಂಡೆಂಟೇಶನ್ ಅನ್ನು ಸರಿಹೊಂದಿಸುತ್ತದೆ. ನಿಯಮಿತ ಅಭಿವ್ಯಕ್ತಿಗಳನ್ನು ಬಳಸಿಕೊಂಡು, ಸ್ಕ್ರಿಪ್ಟ್ ಚುಕ್ಕೆಗಳಿಂದ ಪ್ರಾರಂಭವಾಗುವ ಸಾಲುಗಳನ್ನು ಗುರುತಿಸುತ್ತದೆ (ಉದಾ., ".WithSomething()") ಮತ್ತು ಸ್ಥಿರವಾದ ಇಂಡೆಂಟೇಶನ್ ಅನ್ನು ಅನ್ವಯಿಸುತ್ತದೆ. ಅಂತಹ ಯಾಂತ್ರೀಕೃತಗೊಂಡವು ದೊಡ್ಡ ಕೋಡ್‌ಬೇಸ್‌ಗಳಿಗೆ ವಿಶೇಷವಾಗಿ ಉಪಯುಕ್ತವಾಗಿದೆ, ಅಲ್ಲಿ ಹಸ್ತಚಾಲಿತ ಹಸ್ತಕ್ಷೇಪವು ಸಮಯ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ. ಹೆಚ್ಚುವರಿಯಾಗಿ, ಫಾರ್ಮ್ಯಾಟ್ ಮಾಡಲಾದ ಕೋಡ್ ಉದ್ದೇಶಿತ ಶೈಲಿಗೆ ಹೊಂದಿಕೆಯಾಗುತ್ತದೆ ಎಂಬುದನ್ನು ಮೌಲ್ಯೀಕರಿಸಲು ನಾವು Google ಟೆಸ್ಟ್‌ನಲ್ಲಿ ಬರೆದ ಯುನಿಟ್ ಪರೀಕ್ಷೆಗಳನ್ನು ಸೇರಿಸಿದ್ದೇವೆ, ಇದು ಬಹು ಪರಿಸರದಲ್ಲಿ ದೃಢತೆಯನ್ನು ಖಾತ್ರಿಪಡಿಸುತ್ತದೆ. 🛠️

ಕ್ಲಾಂಗ್-ಫಾರ್ಮ್ಯಾಟ್‌ನೊಂದಿಗೆ ಚೈನ್ಡ್ ಮೆಥಡ್ ಇಂಡೆಂಟೇಶನ್ ಅನ್ನು ಪರಿಪೂರ್ಣಗೊಳಿಸುವುದು

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

ಇದನ್ನು ಪರಿಹರಿಸಲು, ಹೇಗೆ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಮುಖ್ಯವಾಗಿದೆ ಖಣಿಲು-ಫಾರ್ಮ್ಯಾಟ್ ಕೋಡ್ ಅನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುತ್ತದೆ. ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ, ಇದು ನಿಯತಾಂಕಗಳನ್ನು ಅವಲಂಬಿಸಿದೆ ContinuationIndentWidth ಮತ್ತು ಅಲೈನ್ಆಫ್ಟರ್ ಓಪನ್ಬ್ರಾಕೆಟ್. ಆದಾಗ್ಯೂ, ಈ ಕಾನ್ಫಿಗರೇಶನ್‌ಗಳು ಬಹು-ಸಾಲಿನ ಕರೆಗಳನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ನಿಯಂತ್ರಿಸುವುದಿಲ್ಲ. ಉದಾಹರಣೆಗೆ, ಸೆಟ್ಟಿಂಗ್ 0 ಗೆ 0 ಸ್ವಯಂಚಾಲಿತ ಲೈನ್ ಬ್ರೇಕಿಂಗ್ ಅನ್ನು ತಡೆಯುತ್ತದೆ ಆದರೆ ಇಂಡೆಂಟೇಶನ್ ಅನ್ನು ಸರಿಪಡಿಸುವುದಿಲ್ಲ. ಉತ್ತಮ ನಿಯಂತ್ರಣಕ್ಕಾಗಿ, ನಿರ್ದೇಶನಗಳು // clang-format off ಮತ್ತು // clang-format on ಕೋಡ್‌ನ ನಿರ್ದಿಷ್ಟ ಪ್ರದೇಶಗಳಲ್ಲಿ ಫಾರ್ಮ್ಯಾಟಿಂಗ್ ಅನ್ನು ಬೈಪಾಸ್ ಮಾಡಲು ಕಾರ್ಯತಂತ್ರವಾಗಿ ಇರಿಸಬಹುದು.

ಕೆಲವೊಮ್ಮೆ, ತಂಡಗಳಾದ್ಯಂತ ಸ್ಥಿರವಾದ ಫಾರ್ಮ್ಯಾಟಿಂಗ್ ಅತ್ಯಗತ್ಯವಾಗಿರುವ ಯೋಜನೆಗಳಿಗೆ, ಪೋಸ್ಟ್-ಪ್ರೊಸೆಸಿಂಗ್ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳು ಅಥವಾ ಕಸ್ಟಮ್ IDE ಕಾನ್ಫಿಗರೇಶನ್‌ಗಳಂತಹ ಪರಿಕರಗಳು ಅಗತ್ಯವಾಗುತ್ತವೆ. ಉದಾಹರಣೆಗೆ, ಚೈನ್ಡ್ ಕರೆಗಳನ್ನು ಪತ್ತೆಹಚ್ಚುವ ಮತ್ತು ಇಂಡೆಂಟೇಶನ್ ಅನ್ನು ಮರುಹೊಂದಿಸುವ ಪೈಥಾನ್ ಸ್ಕ್ರಿಪ್ಟ್ ಬ್ಯಾಕಪ್ ಪರಿಹಾರವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ. ಈ ವಿಧಾನವು ಸಹ ಖಚಿತಪಡಿಸುತ್ತದೆ ಖಣಿಲು-ಫಾರ್ಮ್ಯಾಟ್ ಗುರುತು ತಪ್ಪಿಸುತ್ತದೆ, ಕೋಡ್ ಬದಲಾವಣೆಯ ನಂತರ ಡೆವಲಪರ್‌ಗಳು ಬಯಸಿದ ಶೈಲಿಯನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಜಾರಿಗೊಳಿಸಬಹುದು. 🚀