ಇತ್ತೀಚಿನ ಕಮಿಟ್ ಮೂಲಕ Git ಶಾಖೆಗಳನ್ನು ವಿಂಗಡಿಸುವುದು ಹೇಗೆ

Git ಶಾಖೆಯ ನಿರ್ವಹಣೆಯನ್ನು ಅನ್ವೇಷಿಸಲಾಗುತ್ತಿದೆ

ಹಲವಾರು ಶಾಖೆಗಳನ್ನು ಒಳಗೊಂಡಿರುವ ದೊಡ್ಡ ರೆಪೊಸಿಟರಿಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವ ಡೆವಲಪರ್‌ಗಳಿಗೆ Git ನಲ್ಲಿ ಶಾಖೆಗಳನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ನಿರ್ವಹಿಸುವುದು ನಿರ್ಣಾಯಕವಾಗಿದೆ. ತೀರಾ ಇತ್ತೀಚೆಗೆ ನವೀಕರಿಸಿದ ಶಾಖೆಗಳನ್ನು ಗುರುತಿಸುವುದು ಒಂದು ಸಾಮಾನ್ಯ ಅವಶ್ಯಕತೆಯಾಗಿದೆ, ಏಕೆಂದರೆ ಇವುಗಳಿಗೆ ತಕ್ಷಣದ ಗಮನ ಬೇಕು. ಈ ಪ್ರಕ್ರಿಯೆಯು ಶಾಖೆಗಳನ್ನು ಪಟ್ಟಿ ಮಾಡುವುದಲ್ಲದೆ ಇತ್ತೀಚಿನ ಬದ್ಧತೆಯ ಸಮಯದ ಆಧಾರದ ಮೇಲೆ ಅವುಗಳನ್ನು ವಿಂಗಡಿಸುವುದನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ.

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

Git ಶಾಖೆಯ ವಿಂಗಡಣೆ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು

ಶೆಲ್ ಸ್ಕ್ರಿಪ್ಟ್ ಮತ್ತು ಪೈಥಾನ್ ಸ್ಕ್ರಿಪ್ಟ್ ಎರಡೂ Git ರೆಪೊಸಿಟರಿಯೊಳಗೆ ಇತ್ತೀಚೆಗೆ ನವೀಕರಿಸಿದ ಶಾಖೆಗಳನ್ನು ಗುರುತಿಸುವ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಸುಗಮಗೊಳಿಸುವ ಗುರಿಯನ್ನು ಹೊಂದಿವೆ. ಶೆಲ್ ಸ್ಕ್ರಿಪ್ಟ್ ಬಳಸುತ್ತದೆ git fetch --all ಸ್ಥಳೀಯ ಶಾಖೆಯ ಉಲ್ಲೇಖಗಳನ್ನು ರಿಮೋಟ್ ರೆಪೊಸಿಟರಿಯೊಂದಿಗೆ ಸಿಂಕ್ರೊನೈಸ್ ಮಾಡಲು ಆದೇಶ, ವಿಂಗಡಿಸುವ ಮೊದಲು ಸ್ಥಳೀಯ ಡೇಟಾ ಪ್ರಸ್ತುತವಾಗಿದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ. ಇದನ್ನು ಅನುಸರಿಸಿ, ದಿ git for-each-ref ಆಜ್ಞೆಯು ಕಾರ್ಯರೂಪಕ್ಕೆ ಬರುತ್ತದೆ, ರೆಪೊಸಿಟರಿಯೊಳಗಿನ ಶಾಖೆಗಳು ಮತ್ತು ಟ್ಯಾಗ್‌ಗಳಂತಹ ಲಭ್ಯವಿರುವ ಎಲ್ಲಾ ಉಲ್ಲೇಖಗಳ ಮೇಲೆ ಪುನರಾವರ್ತನೆ ಮಾಡಲು ಮತ್ತು ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ನಿರ್ವಹಿಸಲು ವಿಶೇಷವಾಗಿ ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ.

ಈ ಆಜ್ಞೆಯನ್ನು ಇದರೊಂದಿಗೆ ಸಂಯೋಜಿಸಲಾಗಿದೆ --sort=-committerdate ಕೊನೆಯ ಕಮಿಟ್‌ನ ದಿನಾಂಕದ ಆಧಾರದ ಮೇಲೆ ಶಾಖೆಗಳನ್ನು ಆರ್ಡರ್ ಮಾಡುವ ಆಯ್ಕೆ, ತೀರಾ ಇತ್ತೀಚೆಗೆ ನವೀಕರಿಸಿದ ಶಾಖೆಗಳನ್ನು ಮೊದಲು ತೋರಿಸುತ್ತದೆ. ಔಟ್ಪುಟ್ ಸ್ವರೂಪವನ್ನು ಬಳಸಿಕೊಂಡು ನಿರ್ದಿಷ್ಟಪಡಿಸಲಾಗಿದೆ --format='%(committerdate:short) %(refname:short)', ಇದು ಪ್ರತಿ ಶಾಖೆಯನ್ನು ಅದರ ಕೊನೆಯ ಬದ್ಧತೆಯ ದಿನಾಂಕದ ಜೊತೆಗೆ ಸಂಕ್ಷಿಪ್ತ ಸ್ವರೂಪದಲ್ಲಿ ಅಂದವಾಗಿ ಪಟ್ಟಿ ಮಾಡುತ್ತದೆ. ಪೈಥಾನ್ ಸ್ಕ್ರಿಪ್ಟ್, ಏತನ್ಮಧ್ಯೆ, ಪೈಥಾನ್ ಪರಿಸರದಲ್ಲಿ ಈ Git ಆಜ್ಞೆಗಳನ್ನು ಬಳಸಿಕೊಳ್ಳುತ್ತದೆ subprocess.check_output() ಕಾರ್ಯ, ಇದು ಆಜ್ಞೆಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತದೆ ಮತ್ತು ಅದರ ಔಟ್ಪುಟ್ ಅನ್ನು ಸೆರೆಹಿಡಿಯುತ್ತದೆ. ಇದು ದೊಡ್ಡ ಪೈಥಾನ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳು ಅಥವಾ ವರ್ಕ್‌ಫ್ಲೋಗಳಲ್ಲಿ ಶಾಖೆಯ ಡೇಟಾದ ಹೆಚ್ಚುವರಿ ಕುಶಲತೆ ಅಥವಾ ಏಕೀಕರಣವನ್ನು ಅನುಮತಿಸುತ್ತದೆ.

git fetch --all
git for-each-ref --sort=-committerdate refs/heads/ --format='%(committerdate:short) %(refname:short)'

import subprocess
import operator
def get_branches_sorted_by_date():
    cmd = "git for-each-ref refs/heads/ --sort=-committerdate --format='%(committerdate:iso8601) %(refname:short)'"
    result = subprocess.check_output(cmd, shell=True)
    branches = result.decode('utf-8').strip().split('\n')
    sorted_branches = sorted(branches, key=lambda x: x.split()[0], reverse=True)
    return sorted_branches
if __name__ == '__main__':
    branches = get_branches_sorted_by_date()
    for branch in branches:
        print(branch)

Git ಶಾಖೆಯ ನಿರ್ವಹಣೆಯನ್ನು ಉತ್ತಮಗೊಳಿಸುವುದು

Git ಶಾಖೆಗಳ ಪರಿಣಾಮಕಾರಿ ನಿರ್ವಹಣೆಯು ಇತ್ತೀಚಿನ ಚಟುವಟಿಕೆಯ ಮೂಲಕ ಶಾಖೆಗಳನ್ನು ವಿಂಗಡಿಸುವುದನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ ಆದರೆ ಸ್ವಚ್ಛ ಮತ್ತು ಸಂಘಟಿತ ಭಂಡಾರವನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ. ಇದರ ಪ್ರಮುಖ ಅಂಶವೆಂದರೆ ನಿಯತಕಾಲಿಕವಾಗಿ ಇನ್ನು ಮುಂದೆ ಅಗತ್ಯವಿಲ್ಲದ ಹಳೆಯ ಶಾಖೆಗಳನ್ನು ಕತ್ತರಿಸುವುದು. ಇದು ರೆಪೊಸಿಟರಿಯನ್ನು ನ್ಯಾವಿಗೇಟ್ ಮಾಡುವಾಗ ಗೊಂದಲವನ್ನು ಕಡಿಮೆ ಮಾಡಲು ಮತ್ತು ಸ್ಪಷ್ಟತೆಯನ್ನು ಸುಧಾರಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ. ಇದಲ್ಲದೆ, ಸಂಘಟಿತ ರೆಪೊಸಿಟರಿಯು ಡೇಟಾದ ವೇಗದ ಮರುಪಡೆಯುವಿಕೆ ಮತ್ತು ಸಂಸ್ಕರಣೆಯನ್ನು ಸುಗಮಗೊಳಿಸುತ್ತದೆ, ಇದು ಅನೇಕ ಡೆವಲಪರ್‌ಗಳು ವಿವಿಧ ಶಾಖೆಗಳಲ್ಲಿ ಏಕಕಾಲದಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಿರುವ ಪರಿಸರದಲ್ಲಿ ನಿರ್ಣಾಯಕವಾಗಿದೆ.

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