ഒരു പ്രത്യേക Git കമ്മിറ്റിൽ എല്ലാ ഫയലുകളും എങ്ങനെ ലിസ്റ്റ് ചെയ്യാം

ഒരു Git കമ്മിറ്റിൽ ഫയലുകൾ കാണുന്നു

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

ഈ ലേഖനത്തിൽ, നൽകിയിരിക്കുന്ന പ്രതിബദ്ധതയിലുള്ള എല്ലാ ഫയലുകളും എങ്ങനെ ശുദ്ധവും ലളിതവുമായ രീതിയിൽ ലിസ്റ്റ് ചെയ്യാമെന്ന് ഞങ്ങൾ പര്യവേക്ഷണം ചെയ്യും. കമാൻഡുകൾ പോലെ git ഷോ വ്യത്യസ്ത വിശദാംശങ്ങളോടൊപ്പം ഫയലുകൾ പ്രദർശിപ്പിക്കുക, മികച്ച വ്യക്തതയ്ക്കും ഉപയോഗക്ഷമതയ്ക്കും വേണ്ടി ഫയലുകളുടെ ഒരു പ്ലെയിൻ ലിസ്റ്റ് അവതരിപ്പിക്കുന്ന രീതികളിൽ ഞങ്ങൾ ശ്രദ്ധ കേന്ദ്രീകരിക്കും.

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

നൽകിയിരിക്കുന്ന സ്ക്രിപ്റ്റുകൾ വ്യത്യസ്ത വിവരങ്ങൾ പ്രദർശിപ്പിക്കാതെ തന്നിരിക്കുന്ന Git കമ്മിറ്റിൻ്റെ ഭാഗമായ എല്ലാ ഫയലുകളും ലിസ്റ്റ് ചെയ്യാൻ സഹായിക്കുന്നു. ഒരു കമ്മിറ്റ് ഹാഷ് ഒരു ആർഗ്യുമെൻ്റായി നൽകിയിട്ടുണ്ടോ എന്ന് പരിശോധിച്ചാണ് ഷെൽ സ്ക്രിപ്റ്റ് ആരംഭിക്കുന്നത്. ഇല്ലെങ്കിൽ, അത് ഒരു ഉപയോഗ സന്ദേശം അച്ചടിച്ച് പുറത്തുകടക്കുന്നു. ഒരു കമ്മിറ്റ് ഹാഷ് നൽകിയിട്ടുണ്ടെങ്കിൽ, അത് കമാൻഡ് പ്രവർത്തിപ്പിക്കുന്നു git diff-tree ഓപ്ഷനുകൾക്കൊപ്പം --no-commit-id, --name-only, ഒപ്പം -r. ഈ കമാൻഡ് പ്ലെയിൻ ഫോർമാറ്റിൽ നിർദ്ദിഷ്ട കമ്മിറ്റ് ബാധിച്ച ഫയലുകൾ പട്ടികപ്പെടുത്തുന്നു. ആവശ്യമില്ലാത്ത വ്യത്യസ്‌ത വിവരങ്ങൾ ഒഴിവാക്കി ഫയലിൻ്റെ പേരുകൾ മാത്രമേ പ്രദർശിപ്പിക്കൂ എന്ന് ഈ രീതി ഉറപ്പാക്കുന്നു. Git ലഭ്യമായ പരിതസ്ഥിതികളിലെ കമ്മിറ്റ് ഉള്ളടക്കങ്ങളുടെ വേഗത്തിലുള്ളതും ലളിതവുമായ ലിസ്റ്റിംഗുകൾക്ക് ഈ സ്ക്രിപ്റ്റ് പ്രത്യേകിച്ചും ഉപയോഗപ്രദമാണ്.

പൈത്തൺ സ്ക്രിപ്റ്റ് സമാനമായ പ്രവർത്തനം നടത്തുന്നു, പക്ഷേ പൈത്തണിൻ്റെ സ്ക്രിപ്റ്റ് ഉപയോഗിക്കുന്നു subprocess പ്രവർത്തിപ്പിക്കാനുള്ള മൊഡ്യൂൾ git diff-tree കമാൻഡ്. ഇത് കമാൻഡിൻ്റെ ഔട്ട്പുട്ട് പിടിച്ചെടുക്കുകയും കൺസോളിലേക്ക് പ്രിൻ്റ് ചെയ്യുകയും ചെയ്യുന്നു. ഈ സ്ക്രിപ്റ്റ് കമാൻഡ്-ലൈൻ ആർഗ്യുമെൻ്റുകളുടെ ശരിയായ എണ്ണം പരിശോധിക്കുന്നു, ആവശ്യമെങ്കിൽ ഒരു പിശക് സന്ദേശം പ്രിൻ്റ് ചെയ്യുന്നു, തുടർന്ന് Git കമാൻഡ് എക്സിക്യൂട്ട് ചെയ്യാൻ തുടരുന്നു. ദി subprocess.run സ്റ്റാൻഡേർഡ് ഔട്ട്പുട്ടും സ്റ്റാൻഡേർഡ് എററും ക്യാപ്ചർ ചെയ്യുന്ന കമാൻഡ് എക്സിക്യൂഷൻ കൈകാര്യം ചെയ്യുന്നതിനായി ഫംഗ്ഷൻ ഇവിടെ ഉപയോഗിക്കുന്നു. പൈത്തൺ വർക്ക്ഫ്ലോകളിലേക്ക് Git പ്രവർത്തനങ്ങൾ സംയോജിപ്പിക്കുന്നതിനും ഒരു പൈത്തൺ ആപ്ലിക്കേഷനിൽ ഔട്ട്പുട്ടിൻ്റെ കൂടുതൽ പ്രോസസ്സിംഗ് ആവശ്യമായി വരുന്ന സന്ദർഭങ്ങളിലും ഈ സമീപനം ഉപയോഗപ്രദമാണ്.

Node.js സ്‌ക്രിപ്‌റ്റും ഇതേ ലക്ഷ്യം കൈവരിക്കുന്നു, പക്ഷേ അത് ഉപയോഗിക്കുന്നു exec Node.js-ൽ നിന്നുള്ള പ്രവർത്തനം child_process മൊഡ്യൂൾ. ഇത് ഒരു കമ്മിറ്റ് ഹാഷ് ഒരു ആർഗ്യുമെൻ്റായി എടുത്ത് അത് എക്സിക്യൂട്ട് ചെയ്യുന്നു git diff-tree ഉചിതമായ ഓപ്ഷനുകളുള്ള കമാൻഡ്. സ്‌ക്രിപ്റ്റ് ഔട്ട്‌പുട്ട് ക്യാപ്‌ചർ ചെയ്‌ത് പ്രിൻ്റ് ചെയ്യുന്നു, എക്‌സിക്യൂഷൻ സമയത്ത് സംഭവിക്കുന്ന ഏതെങ്കിലും പിശകുകൾ കൈകാര്യം ചെയ്യുന്നു. ഒരു JavaScript അല്ലെങ്കിൽ Node.js പരിതസ്ഥിതിയിൽ പ്രവർത്തിക്കുന്ന ഡെവലപ്പർമാർക്ക് ഈ സ്ക്രിപ്റ്റ് പ്രത്യേകിച്ചും പ്രയോജനകരമാണ്, കൂടാതെ അവരുടെ ആപ്ലിക്കേഷനുകളിലോ ഓട്ടോമേറ്റഡ് വർക്ക്ഫ്ലോകളിലോ Git പ്രവർത്തനങ്ങൾ സംയോജിപ്പിക്കേണ്ടതുണ്ട്. ഓരോ സ്ക്രിപ്റ്റും വ്യത്യസ്ത പ്രോഗ്രാമിംഗ് ഭാഷകളുടേയും പരിതസ്ഥിതികളുടേയും വൈദഗ്ധ്യം ഒരു Git കമ്മിറ്റിൽ ഫയലുകൾ ലിസ്റ്റുചെയ്യുന്നതിനുള്ള ഒരേ പ്രശ്നം പരിഹരിക്കുന്നതിന് ഉദാഹരണമാണ്.

#!/bin/bash
# This script lists all files in a given git commit

commit_hash=$1

if [ -z "$commit_hash" ]; then
  echo "Usage: $0 <commit_hash>"
  exit 1
fi

git diff-tree --no-commit-id --name-only -r $commit_hash

import subprocess
import sys

def list_files_in_commit(commit_hash):
    try:
        result = subprocess.run(['git', 'diff-tree', '--no-commit-id', '--name-only', '-r', commit_hash],
                                stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
        if result.returncode != 0:
            print(f"Error: {result.stderr.strip()}")
        else:
            print(result.stdout.strip())
    except Exception as e:
        print(f"An error occurred: {e}")

if __name__ == "__main__":
    if len(sys.argv) != 2:
        print("Usage: python list_files_in_commit.py <commit_hash>")
    else:
        list_files_in_commit(sys.argv[1])

const { exec } = require('child_process');

function listFilesInCommit(commitHash) {
  exec(`git diff-tree --no-commit-id --name-only -r ${commitHash}`, (error, stdout, stderr) => {
    if (error) {
      console.error(`Error: ${stderr}`);
      return;
    }
    console.log(stdout.trim());
  });
}

const commitHash = process.argv[2];

if (!commitHash) {
  console.log('Usage: node listFilesInCommit.js <commitHash>');
} else {
  listFilesInCommit(commitHash);
}

ഒരു Git കമ്മിറ്റിൽ ഫയലുകൾ ലിസ്റ്റുചെയ്യുന്നതിനുള്ള വിപുലമായ സാങ്കേതിക വിദ്യകൾ

അടിസ്ഥാന Git കമാൻഡുകൾ ഉപയോഗിക്കുന്നതിനുമപ്പുറം, ഒരു പ്രത്യേക കമ്മിറ്റിൽ ഫയലുകൾ ലിസ്റ്റുചെയ്യുന്നതിന് മറ്റ് വിപുലമായ സാങ്കേതികതകളും ഉപകരണങ്ങളും ഉണ്ട്. അത്തരമൊരു ഉപകരണം git log വിവിധ ഓപ്ഷനുകളുമായി സംയോജിപ്പിച്ചിരിക്കുന്നു. ഉപയോഗിച്ച് git log കൂടെ --name-only ഒപ്പം --pretty=format: ഓപ്ഷനുകൾ, കൂടുതൽ ഇഷ്‌ടാനുസൃതമാക്കിയ രീതിയിൽ ഫയലുകൾ ലിസ്റ്റുചെയ്യുന്നതിന് നിങ്ങൾക്ക് ഔട്ട്‌പുട്ട് ഫോർമാറ്റ് ചെയ്യാൻ കഴിയും. ഉദാഹരണത്തിന്, git log --name-only --pretty=format:"%h %s" -1 [commit_hash] കമ്മിറ്റ് ഹാഷും സബ്ജക്റ്റും കാണിക്കും, തുടർന്ന് ഫയൽ നാമങ്ങൾ. ഈ രീതി കൂടുതൽ ഫ്ലെക്സിബിൾ ഔട്ട്പുട്ട് അനുവദിക്കുന്നു, റിപ്പോർട്ടുകൾ സൃഷ്ടിക്കുന്നതിനോ മറ്റ് ഉപകരണങ്ങളുമായി സംയോജിപ്പിക്കുന്നതിനോ ഇത് ഉപയോഗപ്രദമാകും.

വ്യത്യസ്ത പ്രോഗ്രാമിംഗ് ഭാഷകൾക്കായി ലഭ്യമായ Git ലൈബ്രറികൾ ഉപയോഗിക്കുന്നതാണ് മറ്റൊരു സമീപനം libgit2 സിക്ക് വേണ്ടി, pygit2 പൈത്തണിനായി, ഒപ്പം nodegit Node.js-ന്. ഈ ലൈബ്രറികൾ Git റിപ്പോസിറ്ററികളുമായി സംവദിക്കാൻ ഒരു പ്രോഗ്രമാറ്റിക് മാർഗം നൽകുന്നു, കൂടാതെ ഒരു കമ്മിറ്റിലെ ഫയലുകൾ പ്രോഗ്രാമാറ്റിക് ആയി ലിസ്റ്റുചെയ്യാനും ഇത് ഉപയോഗിക്കാം. ഉദാഹരണത്തിന്, കൂടെ pygit2, നിങ്ങൾക്ക് ഒരു കമ്മിറ്റ് ഒബ്‌ജക്‌റ്റ് ആക്‌സസ് ചെയ്യാനും ഫയലുകളുടെ ലിസ്റ്റ് ലഭിക്കുന്നതിന് അതിൻ്റെ ട്രീയിൽ ആവർത്തിക്കാനും കഴിയും. ലളിതമായ കമാൻഡ്-ലൈൻ ഔട്ട്‌പുട്ടിനെക്കാൾ സങ്കീർണ്ണമായ ലോജിക് അല്ലെങ്കിൽ ഹാൻഡ്‌ലിങ്ങ് ആവശ്യമുള്ള ആപ്ലിക്കേഷനുകളിലേക്കോ സ്‌ക്രിപ്റ്റുകളിലേക്കോ നിങ്ങൾക്ക് Git ഫംഗ്‌ഷണാലിറ്റി നേരിട്ട് സംയോജിപ്പിക്കേണ്ടിവരുമ്പോൾ ഈ സമീപനം പ്രയോജനകരമാണ്.