git add -A மற்றும் git add .

Arthur Petit

செவ்வாய், 2 ஜூலை, 2024 ’அன்று’ பிற்பகல் 7:08:38

மாஸ்டரிங் Git சேர் கட்டளைகள்
Git உடன் பணிபுரியும் போது, உங்கள் பதிப்புக் கட்டுப்பாட்டை திறம்பட நிர்வகிக்க வெவ்வேறு கட்டளைகளுக்கு இடையே உள்ள நுணுக்கங்களைப் புரிந்துகொள்வது முக்கியம். குழப்பத்தின் ஒரு பொதுவான பகுதி "git add -A" மற்றும் "git add ." ஆகியவற்றுக்கு இடையே உள்ள வேறுபாடு ஆகும், இது உங்கள் களஞ்சியத்தில் மாற்றங்கள் எவ்வாறு அரங்கேற்றப்படுகின்றன என்பதைப் பாதிக்கலாம்.
இந்த கட்டுரையில், இந்த இரண்டு கட்டளைகளின் தனித்துவமான செயல்பாடுகளை ஆராய்வோம். ஒவ்வொன்றையும் எப்போது, ஏன் பயன்படுத்த வேண்டும் என்பதை நாங்கள் தெளிவுபடுத்துவோம், உங்கள் பணிப்பாய்வு மற்றும் திட்ட நிர்வாகத்திற்கான அவற்றின் தாக்கங்களை நீங்கள் தெளிவாகப் புரிந்துகொள்வதை உறுதிசெய்வோம்.

கட்டளை விளக்கம்

git init தற்போதைய கோப்பகத்தில் புதிய Git களஞ்சியத்தை துவக்குகிறது.

mkdir குறிப்பிட்ட பெயருடன் புதிய கோப்பகத்தை உருவாக்குகிறது.

touch குறிப்பிட்ட பெயருடன் புதிய வெற்று கோப்பை உருவாக்குகிறது.

echo ஒரு கோப்பில் குறிப்பிட்ட சரத்தை எழுதுகிறது.

subprocess.Popen பைதான் ஸ்கிரிப்ட்டில் இருந்து ஷெல் கட்டளையை இயக்குகிறது.

process.wait() தொடர்வதற்கு முன் செயல்முறை முடிவடையும் வரை காத்திருக்கிறது.

os.remove குறிப்பிட்ட கோப்பை நீக்குகிறது.

கட்டளை	விளக்கம்
git init	தற்போதைய கோப்பகத்தில் புதிய Git களஞ்சியத்தை துவக்குகிறது.
mkdir	குறிப்பிட்ட பெயருடன் புதிய கோப்பகத்தை உருவாக்குகிறது.
touch	குறிப்பிட்ட பெயருடன் புதிய வெற்று கோப்பை உருவாக்குகிறது.
echo	ஒரு கோப்பில் குறிப்பிட்ட சரத்தை எழுதுகிறது.
subprocess.Popen	பைதான் ஸ்கிரிப்ட்டில் இருந்து ஷெல் கட்டளையை இயக்குகிறது.
process.wait()	தொடர்வதற்கு முன் செயல்முறை முடிவடையும் வரை காத்திருக்கிறது.
os.remove	குறிப்பிட்ட கோப்பை நீக்குகிறது.

ஸ்கிரிப்டிங் மூலம் Git சேர் கட்டளைகளை ஆராய்தல்

வழங்கப்பட்ட ஸ்கிரிப்டுகள் இடையே உள்ள செயல்பாட்டு வேறுபாடுகளை விளக்குகின்றன மற்றும் பாஷ் ஸ்கிரிப்ட் ஒரு புதிய Git களஞ்சியத்தை துவக்குகிறது , பின்னர் கோப்பகங்கள் மற்றும் கோப்புகளை உருவாக்குகிறது mkdir மற்றும் . இந்த கட்டளைகள், ஒரு உறுதிமொழிக்காக கட்டமைக்கக்கூடிய கோப்புகளுடன் செயல்படும் கோப்பகத்தை அமைக்கின்றன. ஸ்கிரிப்ட் பின்னர் பயன்படுத்துகிறது புதிய கோப்புகள், மாற்றங்கள் மற்றும் நீக்குதல்கள் உட்பட அனைத்து மாற்றங்களையும் செயல்படுத்துவதற்கு முன் . இந்த கட்டளை களஞ்சியத்தில் உள்ள அனைத்து மாற்றங்களின் விரிவான சேர்க்கையை உறுதி செய்கிறது.

அடுத்த கட்டத்தில், அடைவு அமைப்பு மற்றும் கோப்புகளில் அதிக மாற்றங்கள் செய்யப்படுகின்றன. புதிய கோப்புகள் உருவாக்கப்படுகின்றன, மேலும் சில மாற்றப்பட்டன அல்லது நீக்கப்படுகின்றன. ஸ்கிரிப்ட் பின்னர் பயன்படுத்துகிறது இந்த மாற்றங்களை அரங்கேற்றுவதற்கு. இங்கே வித்தியாசம் அதுதான் தற்போதைய கோப்பகம் மற்றும் துணை அடைவுகளுக்குள் புதிய மற்றும் மாற்றியமைக்கப்பட்ட கோப்புகளை நிலைப்படுத்துகிறது, ஆனால் இது நீக்கப்பட்ட கோப்புகளை நிலைநிறுத்துவதில்லை. இறுதியாக, ஸ்கிரிப்ட் இந்த மாற்றங்களைச் செய்கிறது மற்றும் பயன்படுத்தி களஞ்சியத்தின் நிலையை காட்டுகிறது git status. Git களஞ்சியத்தை திறம்பட நிர்வகிப்பதில் ஒவ்வொரு கட்டளையின் குறிப்பிட்ட பயன்பாட்டு நிகழ்வுகள் மற்றும் வரம்புகளை இந்த ஆர்ப்பாட்டம் எடுத்துக்காட்டுகிறது.

Git ஸ்டேஜிங்கிற்கான விரிவான வழிகாட்டி: 'git add -A' vs 'git add .'

'git add -A' மற்றும் 'git add .'

#!/bin/bash
# Initialize a new Git repository
git init demo-repo
cd demo-repo

# Create files and directories
mkdir dir1
touch dir1/file1.txt
echo "Hello" > dir1/file1.txt
touch file2.txt
echo "World" > file2.txt

# Stage changes with 'git add -A'
git add -A
git commit -m "Initial commit with -A"

# Make more changes
mkdir dir2
touch dir2/file3.txt
echo "Test" > dir2/file3.txt
echo "Hello World" > file2.txt
rm dir1/file1.txt

# Stage changes with 'git add .'
git add .
git commit -m "Second commit with ."

# Show git status
git status

'git add -A' மற்றும் 'git add .' ஆகியவற்றின் விளைவுகளை விளக்குகிறது.

பைதான் ஸ்கிரிப்ட் 'git add -A' மற்றும் 'git add .'

import os
import subprocess

# Function to run shell commands
def run_command(command):
    process = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE)
    process.wait()

# Initialize a new Git repository
os.mkdir('demo-repo')
os.chdir('demo-repo')
run_command('git init')

# Create files and directories
os.mkdir('dir1')
with open('dir1/file1.txt', 'w') as f:
    f.write('Hello')
with open('file2.txt', 'w') as f:
    f.write('World')

# Stage changes with 'git add -A'
run_command('git add -A')
run_command('git commit -m "Initial commit with -A"')

# Make more changes
os.mkdir('dir2')
with open('dir2/file3.txt', 'w') as f:
    f.write('Test')
with open('file2.txt', 'a') as f:
    f.write(' Hello World')
os.remove('dir1/file1.txt')

# Stage changes with 'git add .'
run_command('git add .')
run_command('git commit -m "Second commit with ."')

# Show git status
run_command('git status')

Git சேர் கட்டளைகளின் நுணுக்கங்களைப் புரிந்துகொள்வது

அடிப்படை செயல்பாடுகளுக்கு கூடுதலாக மற்றும் , வெவ்வேறு பணிப்பாய்வுகளில் அவற்றின் தாக்கத்தைப் புரிந்துகொள்வது முக்கியம். தி மாற்றங்கள், சேர்த்தல் மற்றும் நீக்குதல் உட்பட பணி அடைவில் உள்ள அனைத்து மாற்றங்களையும் கட்டளை நிலைப்படுத்துகிறது. களஞ்சியத்தின் விரிவான புதுப்பிப்பு தேவைப்படும் சூழ்நிலைகளில் இது குறிப்பாக பயனுள்ளதாக இருக்கும். உதாரணமாக, பல கோப்புகள் மற்றும் கோப்பகங்களில் குறியீட்டை மறுசீரமைக்கும்போது, git add -A அனைத்து மாற்றங்களும் கைப்பற்றப்பட்டு, ஒரே உறுதிப்பாட்டிற்குத் தயாராக இருப்பதை உறுதி செய்கிறது. கமிட் செயல்பாட்டின் போது முக்கியமான புதுப்பிப்புகளை இழக்கும் அபாயத்தை இந்த முறை குறைக்கிறது.

மாறாக, தி கட்டளை மிகவும் தேர்ந்தெடுக்கப்பட்டதாகும், தற்போதைய அடைவு மற்றும் அதன் துணை அடைவுகளில் புதிய மற்றும் மாற்றியமைக்கப்பட்ட கோப்புகளை மட்டுமே நிலைநிறுத்துகிறது. மற்ற கட்டளைகளுடன் இணைக்கப்படாவிட்டால் இது நீக்குதல்களை விலக்குகிறது. மாற்றங்களை அடிக்கடி மறுபரிசீலனை செய்து, உறுதியளிப்பதற்கு முன் சோதிக்கப்படும் மறுசெயல் வளர்ச்சி செயல்முறைகளில் இந்த அணுகுமுறை சாதகமானது. பயன்படுத்தி , டெவலப்பர்கள் திட்டத்தின் குறிப்பிட்ட பகுதிகளில் கவனம் செலுத்தலாம், தற்செயலாக தேவையற்ற மாற்றங்களைச் செய்வதற்கான வாய்ப்புகளைக் குறைக்கலாம். இந்த தேர்ந்தெடுக்கப்பட்ட ஸ்டேஜிங் பகுதி புதுப்பிப்புகளை நிர்வகிப்பதற்கு அல்லது ஒரு திட்டத்தில் உள்ள தனித்துவமான அம்சங்களில் பணிபுரியும் போது சிறந்தது.

முதன்மையான பயன் என்ன ?
தி புதிய, மாற்றியமைக்கப்பட்ட மற்றும் நீக்கப்பட்ட கோப்புகள் உட்பட வேலை செய்யும் கோப்பகத்தில் உள்ள அனைத்து மாற்றங்களையும் கட்டளை நிலைப்படுத்துகிறது.
எப்படி செய்கிறது இருந்து வேறுபடுகின்றன ?
தி கட்டளை தற்போதைய அடைவு மற்றும் துணை அடைவுகளுக்குள் புதிய மற்றும் மாற்றியமைக்கப்பட்ட கோப்புகளை நிலைநிறுத்துகிறது ஆனால் நீக்குதல்களை நிலை நிறுத்தாது.
நான் எப்போது பயன்படுத்த வேண்டும் ?
பயன்படுத்தவும் நீங்கள் ஒரு விரிவான உறுதிப்பாட்டிற்காக முழு களஞ்சியத்திலும் அனைத்து மாற்றங்களையும் நிலைநிறுத்த விரும்பினால்.
முடியும் நீக்குதல்களை அரங்கேற்ற பயன்படுமா?
இல்லை, நீக்குதல்களை அரங்கேற்றுவதில்லை. பயன்படுத்தவும் அல்லது நீக்குதல்களை சேர்க்க.
நான் பயன்படுத்தினால் என்ன ஆகும் ரூட் கோப்பகத்தில்?
பயன்படுத்தி ரூட் டைரக்டரியில் புதிய மற்றும் மாற்றியமைக்கப்பட்ட கோப்புகளை முழு களஞ்சியத்திலும் நிலைநிறுத்துகிறது, ஆனால் இன்னும் நீக்குதல்களை விலக்குகிறது.
நீக்கங்களை மட்டும் அரங்கேற்ற வழி உள்ளதா?
ஆம், நீங்கள் பயன்படுத்தலாம் மாற்றங்கள் மற்றும் நீக்குதல்களை மட்டுமே செய்ய வேண்டும், ஆனால் புதிய கோப்புகள் அல்ல.
நான் இணைக்க முடியுமா மற்ற கட்டளைகளுடன்?
ஆம், இணைத்தல் மற்ற Git கட்டளைகளுடன் குறிப்பிட்ட தேவைகளுக்கு ஏற்றவாறு ஸ்டேஜிங் செயல்முறையை செம்மைப்படுத்த உதவும்.

இடையே உள்ள வேறுபாடு மற்றும் துல்லியமான பதிப்பு கட்டுப்பாட்டுக்கு முக்கியமானது. நீக்குதல் உட்பட அனைத்து மாற்றங்களையும் நிலைநிறுத்துகிறது, இது விரிவான புதுப்பிப்புகளுக்கு ஏற்றதாக அமைகிறது. மாறாக, git add . நீக்குதல்களைத் தவிர்த்து, தற்போதைய கோப்பகத்தில் புதிய மற்றும் மாற்றியமைக்கப்பட்ட கோப்புகளை மட்டுமே நிலைநிறுத்துகிறது. இந்த வேறுபாடுகளைப் புரிந்துகொள்வது டெவலப்பர்கள் தங்கள் பணிப்பாய்வுகளை மிகவும் திறம்பட நிர்வகிக்க உதவுகிறது, இதன் மூலம் உத்தேசிக்கப்பட்ட மாற்றங்கள் மட்டுமே களஞ்சியத்தில் உறுதி செய்யப்படுகின்றன.

"git add -A" மற்றும் "git add ." இடையே உள்ள வேறுபாடுகளைப் புரிந்துகொள்வது.

ஸ்கிரிப்டிங் மூலம் Git சேர் கட்டளைகளை ஆராய்தல்

Git ஸ்டேஜிங்கிற்கான விரிவான வழிகாட்டி: 'git add -A' vs 'git add .'

'git add -A' மற்றும் 'git add .' ஆகியவற்றின் விளைவுகளை விளக்குகிறது.

Git சேர் கட்டளைகளின் நுணுக்கங்களைப் புரிந்துகொள்வது