Git ലോഗ് പര്യവേക്ഷണം ചെയ്യുന്നു: വിശദമായ ഫയൽ മാറ്റ ചരിത്രം

വ്യക്തിഗത ഫയലുകൾക്കായി Git ലോഗ് അനാവരണം ചെയ്യുന്നു

ഒരു പ്രോജക്റ്റിലെ ഫയലിൻ്റെ പരിണാമം മനസ്സിലാക്കുന്നത് ഫലപ്രദമായ പതിപ്പ് നിയന്ത്രണത്തിന് നിർണായകമാണ്. ഒരു ജനപ്രിയ പതിപ്പ് നിയന്ത്രണ സംവിധാനമായ Git, മാറ്റങ്ങൾ ട്രാക്കുചെയ്യുന്നതിന് ശക്തമായ കമാൻഡുകൾ വാഗ്ദാനം ചെയ്യുന്നു. ഇവയിൽ, ജിറ്റ് ലോഗ് കമാൻഡ് പ്രതിബദ്ധതയുള്ള ചരിത്രങ്ങൾ പ്രദർശിപ്പിക്കാനുള്ള കഴിവിന് വേറിട്ടുനിൽക്കുന്നു.

എന്നിരുന്നാലും, വിശദമായ വിശകലനത്തിന് കമ്മിറ്റ് ഹിസ്റ്ററി കാണുന്നത് മാത്രം മതിയാകില്ല. ഡെവലപ്പർമാർ പലപ്പോഴും ഒരു ഫയലിനുള്ളിലെ നിർദ്ദിഷ്ട ഉള്ളടക്ക മാറ്റങ്ങൾ കാണേണ്ടതുണ്ട്. കമ്മിറ്റ് ഹിസ്റ്ററി മാത്രമല്ല, ഫയൽ ഉള്ളടക്കത്തിലെ വിശദമായ മാറ്റങ്ങളും കാണുന്നതിന് Git എങ്ങനെ ഉപയോഗിക്കാമെന്ന് ഈ ലേഖനം പര്യവേക്ഷണം ചെയ്യുന്നു.

സ്ക്രിപ്റ്റ് പ്രവർത്തനത്തിൻ്റെ വിശദമായ വിശദീകരണം

നൽകിയിരിക്കുന്ന സ്‌ക്രിപ്റ്റുകൾ രൂപകൽപ്പന ചെയ്‌തിരിക്കുന്നത് ഉപയോക്താക്കളെ Git ഉപയോഗിച്ച് ഒരു നിർദ്ദിഷ്‌ട ഫയലിലെ മാറ്റങ്ങളുടെ വിശദമായ ചരിത്രം കാണാൻ സഹായിക്കുന്നതിന് വേണ്ടിയാണ്. ഒരു ഫയലിൻ്റെ പേര് നൽകിയിട്ടുണ്ടോ എന്ന് പരിശോധിച്ച് ഷെൽ സ്ക്രിപ്റ്റ് ആരംഭിക്കുന്നു; ഇല്ലെങ്കിൽ, അത് ഒരു ഉപയോഗ സന്ദേശം പ്രദർശിപ്പിക്കുകയും പുറത്തുകടക്കുകയും ചെയ്യുന്നു. ഒരു ഫയൽനാമം നൽകുമ്പോൾ, ഇത് ഒരു വേരിയബിളിലേക്ക് അസൈൻ ചെയ്യുന്നു, തുടർന്ന് ഫയൽ പുനർനാമകരണം ചെയ്താലും ഫയൽ ചരിത്രം ട്രാക്കുചെയ്യുന്നതിന് **--follow** ഓപ്ഷനുള്ള **git log** കമാൻഡ് പ്രവർത്തിപ്പിക്കുന്നു. ലോഗ് ഔട്ട്പുട്ട് ഇഷ്ടാനുസൃതമാക്കാൻ **--pretty=format** ഓപ്ഷൻ ഉപയോഗിക്കുന്നു, കമ്മിറ്റ് ഹാഷ്, രചയിതാവ്, തീയതി, കമ്മിറ്റ് സന്ദേശം എന്നിവ കാണിക്കുന്നു. സ്‌ക്രിപ്റ്റ് പിന്നീട് ലോഗ് ഔട്ട്‌പുട്ട് വരി വരിയായി വായിക്കുന്നു. ലൈനിൽ ഫയലിൻ്റെ പേര് അടങ്ങിയിട്ടുണ്ടെങ്കിൽ, അത് കമ്മിറ്റ് ഹാഷ് എക്‌സ്‌ട്രാക്‌റ്റ് ചെയ്യുകയും ഫയലിൻ്റെ ഉള്ളടക്കങ്ങൾ ആ കമ്മിറ്റിൽ ഉണ്ടായിരുന്നതുപോലെ പ്രദർശിപ്പിക്കുന്നതിന് **git show** കമാൻഡ് ഉപയോഗിക്കുകയും ചെയ്യുന്നു.

പൈത്തൺ സ്ക്രിപ്റ്റ് സമാനമായ പ്രവർത്തനക്ഷമത കൈവരിക്കുന്നു. ഇത് **os**, **sys** എന്നിവ പോലുള്ള ആവശ്യമായ മൊഡ്യൂളുകൾ ഇറക്കുമതി ചെയ്യുന്നു, തുടർന്ന് ഒരു ഫയൽനാമം ഒരു ആർഗ്യുമെൻ്റായി എടുക്കുന്ന ഒരു ഫംഗ്‌ഷൻ **get_git_log** നിർവചിക്കുന്നു. ഷെൽ സ്ക്രിപ്റ്റിന് സമാനമായ ഓപ്ഷനുകളുള്ള ഒരു **git log** കമാൻഡ് ഈ ഫംഗ്ഷൻ നിർമ്മിക്കുന്നു. ലോഗ് ഔട്ട്പുട്ട് വായിക്കുകയും വ്യക്തിഗത വരികളായി വിഭജിക്കുകയും ചെയ്യുന്നു. ഫയലിൻ്റെ പേര് അടങ്ങിയിരിക്കുന്ന ഓരോ വരിയിലും, അത് കമ്മിറ്റ് ഹാഷ് എക്‌സ്‌ട്രാക്‌റ്റ് ചെയ്യുകയും ഫയലിൻ്റെ ഉള്ളടക്കങ്ങൾ പ്രദർശിപ്പിക്കുന്നതിന് **git show** കമാൻഡ് നിർമ്മിക്കുകയും ചെയ്യുന്നു. ഫയലിൻ്റെ പേര് സ്ക്രിപ്റ്റിന് ഒരു ആർഗ്യുമെൻ്റായി നൽകിയിട്ടില്ലെങ്കിൽ, അത് ഒരു ഉപയോഗ സന്ദേശം അച്ചടിച്ച് പുറത്തുകടക്കുന്നു. വിശദമായ ഫയൽ മാറ്റ ചരിത്രങ്ങൾ കാണുന്നതിന് ശക്തമായ ഒരു പരിഹാരം നൽകുന്നതിന് ഷെൽ കമാൻഡുകളും സ്ട്രിംഗ് കൃത്രിമത്വവും കൈകാര്യം ചെയ്യുന്നതിനുള്ള പൈത്തണിൻ്റെ കഴിവിനെ ഈ സ്ക്രിപ്റ്റ് പ്രയോജനപ്പെടുത്തുന്നു.

വിശദമായ ഫയൽ മാറ്റങ്ങൾ കാണുന്നതിന് Git ലോഗ് ഉപയോഗിക്കുന്നു

വിശദമായ ജിറ്റ് ലോഗ് വിശകലനത്തിനുള്ള ഷെൽ സ്ക്രിപ്റ്റ്

# Shell script to view file change history with details
#!/bin/bash

# Check if a filename is provided
if [ -z "$1" ]; then
  echo "Usage: $0 <filename>"
  exit 1
fi

filename=$1

# Display the commit history and diff for each commit
git log --follow --pretty=format:"%h - %an, %ar : %s" --name-status $filename | while read line; do
  if [[ $line == *".*" ]]; then
    commit=$(echo $line | awk '{print $1}')
    git show $commit:$filename
  else
    echo $line
  fi
done

പൈത്തൺ ഉപയോഗിച്ച് ജിറ്റ് ലോഗ് ഓട്ടോമേറ്റ് ചെയ്യുന്നു

Git ലോഗ് വിശദാംശങ്ങൾ എക്‌സ്‌ട്രാക്‌റ്റ് ചെയ്യാനും പ്രദർശിപ്പിക്കാനും പൈത്തൺ സ്‌ക്രിപ്റ്റ്

import os
import sys

def get_git_log(filename):
    log_command = f"git log --follow --pretty=format:'%h - %an, %ar : %s' --name-status {filename}"
    logs = os.popen(log_command).read().strip().split('\n')
    for log in logs:
        if filename in log:
            commit = log.split()[0]
            diff_command = f"git show {commit}:{filename}"
            diff = os.popen(diff_command).read().strip()
            print(diff)
        else:
            print(log)

if __name__ == "__main__":
    if len(sys.argv) != 2:
        print("Usage: python script.py <filename>")
        sys.exit(1)
    filename = sys.argv[1]
    get_git_log(filename)

Git-ൽ ഫയൽ ചരിത്രം കാണുന്നതിനുള്ള വിപുലമായ സാങ്കേതിക വിദ്യകൾ

അടിസ്ഥാന കൂടാതെ git log കമാൻഡ്, ഒരു ഫയലിൻ്റെ ചരിത്രം കൂടുതൽ വിശദമായി വിശകലനം ചെയ്യുന്നതിനായി Git നിരവധി വിപുലമായ ഓപ്ഷനുകൾ നൽകുന്നു. അത്തരമൊരു ഓപ്ഷൻ ആണ് git blame, ഏത് പുനരവലോകനവും രചയിതാവും ഒരു ഫയലിൻ്റെ ഓരോ വരിയും അവസാനം പരിഷ്കരിച്ചത് കാണിക്കുന്നു. ഒരു നിർദ്ദിഷ്‌ട മാറ്റം എപ്പോൾ വരുത്തിയെന്നും ആരാണെന്നും ട്രാക്ക് ചെയ്യുന്നതിന് ഇത് അവിശ്വസനീയമാംവിധം ഉപയോഗപ്രദമാകും. മറ്റൊരു ശക്തമായ ഉപകരണം git diff, എന്നിവയുമായി ചേർന്ന് ഉപയോഗിക്കാം git log ഓരോ കമ്മിറ്റിലും അവതരിപ്പിച്ച യഥാർത്ഥ മാറ്റങ്ങൾ കാണിക്കാൻ. ഉപയോഗിച്ച് git log -p, നിങ്ങൾക്ക് കമ്മിറ്റ് ചരിത്രത്തോടൊപ്പം പാച്ച് (വ്യത്യാസം) വിവരങ്ങൾ പ്രദർശിപ്പിക്കാൻ കഴിയും, ഓരോ കമ്മിറ്റിലും വരുത്തിയ മാറ്റങ്ങളുടെ വിശദമായ കാഴ്ച നൽകുന്നു.

കമ്മിറ്റ് ചരിത്രത്തിൻ്റെ കൂടുതൽ ഗ്രാഫിക്കൽ പ്രാതിനിധ്യത്തിന്, പോലുള്ള ഉപകരണങ്ങൾ gitk അഥവാ git log --graph ജോലി ചെയ്യാം. ഈ കമാൻഡുകൾ കമ്മിറ്റ് ഹിസ്റ്ററിയെ ഒരു ഗ്രാഫായി ദൃശ്യവൽക്കരിക്കുന്നു, ഇത് ബ്രാഞ്ചിംഗും ലയന പ്രവർത്തനങ്ങളും മനസ്സിലാക്കുന്നത് എളുപ്പമാക്കുന്നു. കൂടാതെ, IDE-കളുമായി Git സംയോജിപ്പിക്കുന്നത് അല്ലെങ്കിൽ SourceTree, GitKraken അല്ലെങ്കിൽ GitHub ഡെസ്‌ക്‌ടോപ്പ് പോലുള്ള GUI ടൂളുകൾ ഉപയോഗിക്കുന്നത് പ്രതിബദ്ധതയുള്ള ചരിത്രവും മാറ്റങ്ങളും പര്യവേക്ഷണം ചെയ്യുന്നതിനുള്ള ഒരു അവബോധജന്യമായ ഇൻ്റർഫേസ് നൽകും. ഈ ടൂളുകളിൽ പലപ്പോഴും കുറ്റപ്പെടുത്തുന്ന കാഴ്‌ചകൾ, വിശദമായ വ്യത്യാസങ്ങൾ, ചരിത്ര ഗ്രാഫുകൾ എന്നിവ പോലുള്ള സവിശേഷതകൾ ഉൾപ്പെടുന്നു, ഇത് Git-ൻ്റെ ശക്തമായ പതിപ്പ് നിയന്ത്രണ ശേഷികളുടെ ഉപയോഗക്ഷമതയും പ്രവേശനക്ഷമതയും വർദ്ധിപ്പിക്കുന്നു.

Git-ൽ ഫയൽ ചരിത്രം കാണുന്നതിനെക്കുറിച്ചുള്ള പൊതുവായ ചോദ്യങ്ങളും ഉത്തരങ്ങളും

1. Git-ലെ ഒരു ഫയലിൻ്റെ കമ്മിറ്റ് ഹിസ്റ്ററി ഞാൻ എങ്ങനെ കാണും?
2. ഉപയോഗിക്കുക git log -- [filename] ഒരു നിർദ്ദിഷ്ട ഫയലിൻ്റെ കമ്മിറ്റ് ചരിത്രം കാണാനുള്ള കമാൻഡ്.
3. ഒരു ഫയലിനായുള്ള ഓരോ കമ്മിറ്റിലും വരുത്തിയ മാറ്റങ്ങൾ എനിക്ക് എങ്ങനെ കാണാനാകും?
4. ഉപയോഗിക്കുക git log -p -- [filename] ഓരോ കമ്മിറ്റിനും പാച്ച് (വ്യത്യാസം) വിവരങ്ങൾ കാണാനുള്ള കമാൻഡ്.
5. എന്താണ് ചെയ്യുന്നത് git blame കമാൻഡ് ചെയ്യണോ?
6. ദി git blame കമാൻഡ് പുനരവലോകനം കാണിക്കുന്നു, കൂടാതെ ഒരു ഫയലിൻ്റെ ഓരോ വരിയും അവസാനമായി പരിഷ്കരിച്ച രചയിതാവ്.
7. കമ്മിറ്റ് ഹിസ്റ്ററി ഒരു ഗ്രാഫായി എനിക്ക് എങ്ങനെ കാണാനാകും?
8. ഉപയോഗിക്കുക git log --graph കമ്മിറ്റ് ഹിസ്റ്ററി ഒരു ഗ്രാഫായി ദൃശ്യമാക്കാനുള്ള കമാൻഡ്.
9. Git ചരിത്രം കാണുന്നതിന് ഗ്രാഫിക്കൽ ടൂളുകൾ ഉണ്ടോ?
10. അതെ, പോലുള്ള ഉപകരണങ്ങൾ SourceTree, GitKraken, ഒപ്പം GitHub Desktop Git ചരിത്രം കാണുന്നതിന് ഗ്രാഫിക്കൽ ഇൻ്റർഫേസുകൾ നൽകുക.
11. പുനർനാമകരണം ചെയ്ത ഫയലിലെ മാറ്റങ്ങൾ എങ്ങനെ ട്രാക്ക് ചെയ്യാം?
12. ഉപയോഗിക്കുക git log --follow -- [filename] പുനർനാമകരണങ്ങളിലുടനീളം ചരിത്രം ട്രാക്കുചെയ്യുന്നതിനുള്ള കമാൻഡ്.
13. ഒരു IDE-യിൽ ഒരു ഫയലിൻ്റെ ചരിത്രം എനിക്ക് കാണാൻ കഴിയുമോ?
14. അതെ, വിഷ്വൽ സ്റ്റുഡിയോ കോഡ്, IntelliJ IDEA എന്നിവ പോലെയുള്ള നിരവധി IDE-കൾക്ക് അന്തർനിർമ്മിത Git ഹിസ്റ്ററി കാണാനുള്ള കഴിവുണ്ട്.

Git ഫയൽ ചരിത്ര വിശകലനത്തിനുള്ള സമഗ്രമായ സാങ്കേതിക വിദ്യകൾ

അടിസ്ഥാന കൂടാതെ git log കമാൻഡ്, ഒരു ഫയലിൻ്റെ ചരിത്രം കൂടുതൽ വിശദമായി വിശകലനം ചെയ്യുന്നതിനായി Git നിരവധി വിപുലമായ ഓപ്ഷനുകൾ നൽകുന്നു. അത്തരമൊരു ഓപ്ഷൻ ആണ് git blame, ഏത് പുനരവലോകനവും രചയിതാവും ഒരു ഫയലിൻ്റെ ഓരോ വരിയും അവസാനം പരിഷ്കരിച്ചത് എന്താണെന്ന് കാണിക്കുന്നു. ഒരു നിർദ്ദിഷ്‌ട മാറ്റം വരുത്തിയതും ആരാണെന്നതും ട്രാക്ക് ചെയ്യുന്നതിന് ഇത് അവിശ്വസനീയമാംവിധം ഉപയോഗപ്രദമാകും. മറ്റൊരു ശക്തമായ ഉപകരണം git diff, എന്നിവയുമായി ചേർന്ന് ഉപയോഗിക്കാം git log ഓരോ കമ്മിറ്റിലും അവതരിപ്പിച്ച യഥാർത്ഥ മാറ്റങ്ങൾ കാണിക്കാൻ. ഉപയോഗിച്ച് git log -p, നിങ്ങൾക്ക് കമ്മിറ്റ് ചരിത്രത്തോടൊപ്പം പാച്ച് (വ്യത്യാസം) വിവരങ്ങൾ പ്രദർശിപ്പിക്കാൻ കഴിയും, ഓരോ കമ്മിറ്റിലും വരുത്തിയ മാറ്റങ്ങളുടെ വിശദമായ കാഴ്ച നൽകുന്നു.

കമ്മിറ്റ് ചരിത്രത്തിൻ്റെ കൂടുതൽ ഗ്രാഫിക്കൽ പ്രാതിനിധ്യത്തിന്, പോലുള്ള ഉപകരണങ്ങൾ gitk അഥവാ git log --graph ജോലി ചെയ്യാം. ഈ കമാൻഡുകൾ കമ്മിറ്റ് ഹിസ്റ്ററിയെ ഒരു ഗ്രാഫായി ദൃശ്യവൽക്കരിക്കുന്നു, ഇത് ബ്രാഞ്ചിംഗും ലയന പ്രവർത്തനങ്ങളും മനസ്സിലാക്കുന്നത് എളുപ്പമാക്കുന്നു. കൂടാതെ, IDE-കളുമായി Git സംയോജിപ്പിക്കുന്നത് അല്ലെങ്കിൽ SourceTree, GitKraken അല്ലെങ്കിൽ GitHub ഡെസ്ക്ടോപ്പ് പോലുള്ള GUI ടൂളുകൾ ഉപയോഗിക്കുന്നത്, കമ്മിറ്റ് ചരിത്രവും മാറ്റങ്ങളും പര്യവേക്ഷണം ചെയ്യുന്നതിനുള്ള ഒരു അവബോധജന്യമായ ഇൻ്റർഫേസ് നൽകാം. ഈ ടൂളുകളിൽ പലപ്പോഴും കുറ്റപ്പെടുത്തുന്ന കാഴ്‌ചകൾ, വിശദമായ വ്യത്യാസങ്ങൾ, ചരിത്ര ഗ്രാഫുകൾ എന്നിവ പോലുള്ള സവിശേഷതകൾ ഉൾപ്പെടുന്നു, ഇത് Git-ൻ്റെ ശക്തമായ പതിപ്പ് നിയന്ത്രണ ശേഷികളുടെ ഉപയോഗക്ഷമതയും പ്രവേശനക്ഷമതയും വർദ്ധിപ്പിക്കുന്നു.

ടെക്നിക്കുകൾ പൊതിയുന്നു

ഫലപ്രദമായ പതിപ്പ് നിയന്ത്രണത്തിന് Git-ലെ ഒരു ഫയലിൻ്റെ വിശദമായ ചരിത്രം മനസ്സിലാക്കുന്നത് വളരെ പ്രധാനമാണ്. തുടങ്ങിയ കമാൻഡുകൾ ഉപയോഗിച്ച് git log, git blame, ഒപ്പം git diff, ഗ്രാഫിക്കൽ ടൂളുകൾക്കൊപ്പം, നിങ്ങളുടെ കോഡ്ബേസിൻ്റെ പരിണാമത്തെക്കുറിച്ച് ആഴത്തിലുള്ള ഉൾക്കാഴ്ചകൾ നിങ്ങൾക്ക് നേടാനാകും. ഈ ടെക്നിക്കുകൾ നിർദ്ദിഷ്ട മാറ്റങ്ങൾ തിരിച്ചറിയുന്നതിനും, കർത്തൃത്വം ട്രാക്ക് ചെയ്യുന്നതിനും, കമ്മിറ്റ് ഹിസ്റ്ററി ദൃശ്യവൽക്കരിക്കുന്നതിനും, ഡെവലപ്പർമാർക്ക് Git ഒരു ഒഴിച്ചുകൂടാനാവാത്ത ഉപകരണമാക്കി മാറ്റുന്നതിനും സഹായിക്കുന്നു.