ਗਿੱਟ ਨੂੰ ਸਮਝਣਾ: ਐਡ ਕਮਾਂਡਾਂ ਵਿਚਕਾਰ ਅੰਤਰ

ਗਿੱਟ ਐਡ ਕਮਾਂਡਾਂ ਦੀਆਂ ਮੂਲ ਗੱਲਾਂ ਦੀ ਪੜਚੋਲ ਕਰਨਾ

Git ਨਾਲ ਪ੍ਰੋਜੈਕਟਾਂ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਦੇ ਸਮੇਂ, ਫਾਈਲ ਸਟੇਜਿੰਗ ਕਮਾਂਡਾਂ ਦੀਆਂ ਬਾਰੀਕੀਆਂ ਨੂੰ ਸਮਝਣਾ ਮਹੱਤਵਪੂਰਨ ਹੁੰਦਾ ਹੈ। 'git add' ਕਮਾਂਡ ਤੁਹਾਡੀ ਰਿਪੋਜ਼ਟਰੀ ਵਿੱਚ ਤਬਦੀਲੀਆਂ ਨੂੰ ਟਰੈਕ ਕਰਨ ਲਈ ਬੁਨਿਆਦੀ ਹੈ। ਇਹ ਤੁਹਾਡੀਆਂ ਤਬਦੀਲੀਆਂ ਕਰਨ ਲਈ ਇੱਕ ਪੂਰਵ-ਸੂਚਕ ਵਜੋਂ ਕੰਮ ਕਰਦਾ ਹੈ, ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਅਗਲੇ ਸਨੈਪਸ਼ਾਟ ਵਿੱਚ ਸਿਰਫ਼ ਲੋੜੀਂਦੀਆਂ ਸੋਧਾਂ ਹੀ ਸ਼ਾਮਲ ਕੀਤੀਆਂ ਗਈਆਂ ਹਨ। ਇਹ ਕਮਾਂਡ ਕਈ ਤਰੀਕਿਆਂ ਨਾਲ ਵਰਤੀ ਜਾ ਸਕਦੀ ਹੈ, ਹਰ ਇੱਕ ਇਸਦੇ ਖਾਸ ਸੰਦਰਭ ਅਤੇ ਪ੍ਰਭਾਵਾਂ ਦੇ ਨਾਲ।

ਦੋ ਆਮ ਭਿੰਨਤਾਵਾਂ 'git add -A' ਅਤੇ 'git add.' ਹਨ, ਜੋ ਕਿ ਇੱਕ ਸਮਾਨ ਜਾਪਦੀਆਂ ਹਨ ਪਰ ਹੁੱਡ ਦੇ ਹੇਠਾਂ ਵੱਖ-ਵੱਖ ਵਿਵਹਾਰ ਕਰਦੀਆਂ ਹਨ। ਇਹਨਾਂ ਅੰਤਰਾਂ ਨੂੰ ਸਮਝਣਾ ਕੁਸ਼ਲ ਸੰਸਕਰਣ ਨਿਯੰਤਰਣ ਲਈ ਜ਼ਰੂਰੀ ਹੈ ਅਤੇ ਗਲਤ ਵਰਤੋਂ ਨਾਲ ਹੋਣ ਵਾਲੇ ਆਮ ਨੁਕਸਾਨਾਂ ਤੋਂ ਬਚਣ ਲਈ ਜ਼ਰੂਰੀ ਹੈ। ਇਹ ਜਾਣ-ਪਛਾਣ ਇੱਕ ਡੂੰਘੀ ਡੁਬਕੀ ਲਈ ਪੜਾਅ ਨਿਰਧਾਰਤ ਕਰਦੀ ਹੈ ਕਿ ਕਿਵੇਂ ਹਰੇਕ ਕਮਾਂਡ ਸਟੇਜਿੰਗ ਖੇਤਰ ਅਤੇ ਤੁਹਾਡੀ ਰਿਪੋਜ਼ਟਰੀ ਦੀ ਸਥਿਤੀ ਨੂੰ ਪ੍ਰਭਾਵਤ ਕਰਦੀ ਹੈ।

ਹੁਕਮ	ਵਰਣਨ
addEventListener	JavaScript ਵਿਧੀ ਇੱਕ ਇਵੈਂਟ ਹੈਂਡਲਰ ਨੂੰ ਦਸਤਾਵੇਜ਼ ਆਬਜੈਕਟ ਮਾਡਲ (DOM) ਤੱਤ ਨਾਲ ਜੋੜਨ ਲਈ ਵਰਤੀ ਜਾਂਦੀ ਹੈ।
Promise	ਇੱਕ ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਆਬਜੈਕਟ ਜੋ ਕਿਸੇ ਅਸਿੰਕ੍ਰੋਨਸ ਓਪਰੇਸ਼ਨ ਦੇ ਅੰਤਮ ਸੰਪੂਰਨਤਾ ਜਾਂ ਅਸਫਲਤਾ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ।
setTimeout	ਇੱਕ JavaScript ਫੰਕਸ਼ਨ ਇੱਕ ਨਿਸ਼ਚਿਤ ਸਮੇਂ ਦੇਰੀ (ਮਿਲੀਸਕਿੰਟ ਵਿੱਚ) ਤੋਂ ਬਾਅਦ ਇੱਕ ਹੋਰ ਫੰਕਸ਼ਨ ਨੂੰ ਚਲਾਉਣ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ।
subprocess.run	ਉਪ-ਪ੍ਰਕਿਰਿਆ ਮੋਡੀਊਲ ਵਿੱਚ ਪਾਈਥਨ ਵਿਧੀ ਸਿੱਧੇ ਤੌਰ 'ਤੇ ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਚਲਾਉਣ ਅਤੇ ਇਸਦੇ ਪੂਰਾ ਹੋਣ ਦੀ ਉਡੀਕ ਕਰਨ ਲਈ।
check=True	Python ਦੇ subprocess.run ਵਿੱਚ ਪੈਰਾਮੀਟਰ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ ਤਾਂ ਜੋ ਇਹ ਯਕੀਨੀ ਬਣਾਇਆ ਜਾ ਸਕੇ ਕਿ ਪ੍ਰਕਿਰਿਆ ਦੀਆਂ ਗਲਤੀਆਂ 'ਤੇ ਇੱਕ ਅਪਵਾਦ ਪੈਦਾ ਕੀਤਾ ਗਿਆ ਹੈ।
console.log	JavaScript ਫੰਕਸ਼ਨ ਵੈੱਬ ਕੰਸੋਲ ਵਿੱਚ ਸੁਨੇਹਿਆਂ ਨੂੰ ਆਉਟਪੁੱਟ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ, ਡੀਬੱਗਿੰਗ ਲਈ ਉਪਯੋਗੀ।

ਸਕ੍ਰਿਪਟ ਕਾਰਜਸ਼ੀਲਤਾ ਸੰਖੇਪ ਜਾਣਕਾਰੀ

JavaScript ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਫਰੰਟ-ਐਂਡ ਸਕ੍ਰਿਪਟ ਉਪਭੋਗਤਾਵਾਂ ਨੂੰ ਗਿੱਟ ਸਟੇਜਿੰਗ ਕਮਾਂਡਾਂ ਨੂੰ ਕਰਨ ਲਈ ਇੰਟਰਐਕਟਿਵ ਬਟਨ ਪ੍ਰਦਾਨ ਕਰਨ ਲਈ ਤਿਆਰ ਕੀਤੀ ਗਈ ਹੈ। ਜਦੋਂ ਕੋਈ ਉਪਭੋਗਤਾ ਜਾਂ ਤਾਂ 'Add All' ਜਾਂ 'Add Current Directory' ਬਟਨ 'ਤੇ ਕਲਿੱਕ ਕਰਦਾ ਹੈ, ਤਾਂ ਸੰਬੰਧਿਤ ਇੱਕ ਫੰਕਸ਼ਨ ਨੂੰ ਚਾਲੂ ਕਰਦਾ ਹੈ ਜੋ ਇੱਕ Git ਕਮਾਂਡ ਨੂੰ ਚਲਾਉਂਦਾ ਹੈ। ਫੰਕਸ਼ਨ ਏ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਨ ਅਸਿੰਕ੍ਰੋਨਸ ਓਪਰੇਸ਼ਨਾਂ ਨੂੰ ਸੰਭਾਲਣ ਲਈ, ਗਿੱਟ ਕਮਾਂਡਾਂ ਨੂੰ ਚਲਾਉਣ ਵਿੱਚ ਦੇਰੀ ਅਤੇ ਸੰਭਾਵੀ ਸਫਲਤਾ ਜਾਂ ਅਸਫਲਤਾ ਦੀ ਨਕਲ ਕਰਨਾ। ਇਹ ਸਿਮੂਲੇਸ਼ਨ ਉਪਭੋਗਤਾਵਾਂ ਨੂੰ ਰੀਅਲ-ਟਾਈਮ ਕਮਾਂਡ-ਲਾਈਨ ਇੰਟਰੈਕਸ਼ਨ ਤੋਂ ਬਿਨਾਂ ਉਹਨਾਂ ਦੀਆਂ ਕਾਰਵਾਈਆਂ ਦੇ ਨਤੀਜੇ ਨੂੰ ਸਮਝਣ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ।

ਪਾਈਥਨ ਵਿੱਚ ਲਿਖੀ ਗਈ ਬੈਕਐਂਡ ਸਕ੍ਰਿਪਟ ਵਿੱਚ, ਦੀ ਵਰਤੋਂ ਵਿਧੀ ਸਕ੍ਰਿਪਟ ਨੂੰ ਪਾਇਥਨ ਤੋਂ ਸਿੱਧੇ ਗਿੱਟ ਕਮਾਂਡਾਂ ਨੂੰ ਕਾਲ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ। ਇਹ ਵਿਧੀ ਸਾਫਟਵੇਅਰ ਐਪਲੀਕੇਸ਼ਨਾਂ ਜਾਂ ਡਿਵੈਲਪਮੈਂਟ ਸਕ੍ਰਿਪਟਾਂ ਵਿੱਚ ਗਿੱਟ ਓਪਰੇਸ਼ਨਾਂ ਨੂੰ ਸਵੈਚਾਲਤ ਕਰਨ ਲਈ ਮਹੱਤਵਪੂਰਨ ਹੈ। ਦ ਪੈਰਾਮੀਟਰ ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਜੇਕਰ ਕਮਾਂਡ ਫੇਲ ਹੋ ਜਾਂਦੀ ਹੈ ਤਾਂ ਇੱਕ ਅਪਵਾਦ ਉਠਾਇਆ ਜਾਂਦਾ ਹੈ, ਜੋ ਕਿ ਆਟੋਮੇਟਿਡ ਸਕ੍ਰਿਪਟਾਂ ਵਿੱਚ ਗਲਤੀ ਨੂੰ ਸੰਭਾਲਣ ਲਈ ਜ਼ਰੂਰੀ ਹੈ। ਇਹ ਸਕ੍ਰਿਪਟ ਦਰਸਾਉਂਦੀ ਹੈ ਕਿ ਇੱਕ ਗਿਟ ਰਿਪੋਜ਼ਟਰੀ ਦੇ ਸਟੇਜਿੰਗ ਖੇਤਰ ਨੂੰ ਪ੍ਰੋਗਰਾਮੇਟਿਕ ਤੌਰ 'ਤੇ ਕਿਵੇਂ ਪ੍ਰਬੰਧਿਤ ਕਰਨਾ ਹੈ, ਵਧੇਰੇ ਗੁੰਝਲਦਾਰ ਸੰਸਕਰਣ ਨਿਯੰਤਰਣ ਆਟੋਮੇਸ਼ਨ ਕਾਰਜਾਂ ਲਈ ਇੱਕ ਬੁਨਿਆਦ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ।

// This is a simplified front-end script to handle Git add operations
document.getElementById('addAll').addEventListener('click', function() {
  executeGitCommand('git add -A').then(displaySuccess).catch(displayError);
});
document.getElementById('addCurrent').addEventListener('click', function() {
  executeGitCommand('git add .').then(displaySuccess).catch(displayError);
});
function executeGitCommand(command) {
  return new Promise((resolve, reject) => {
    // Simulate command execution
    console.log('Executing:', command);
    setTimeout(() => {
      if (Math.random() > 0.5) resolve('Command executed successfully');
      else reject('Error executing command');
    }, 1000);
  });
}
function displaySuccess(message) {
  console.log('Success:', message);
}
function displayError(error) {
  console.error('Error:', error);
}

# This is a backend script to demonstrate git add operations using Python
import subprocess
def git_add_all():
    try:
        subprocess.run(['git', 'add', '-A'], check=True)
        print('Added all changes to staging area')
    except subprocess.CalledProcessError as e:
        print('Failed to add all changes:', e)
def git_add_current_directory():
    try:
        subprocess.run(['git', 'add', '.'], check=True)
        print('Added current directory changes to staging area')
    except subprocess.CalledProcessError as e:
        print('Failed to add current directory:', e)
if __name__ == '__main__':
    git_add_all()  # Example usage
    git_add_current_directory()  # Example usage

ਗਿੱਟ ਸਟੇਜਿੰਗ ਤਕਨੀਕਾਂ ਵਿੱਚ ਡੂੰਘੀ ਗੋਤਾਖੋਰੀ ਕਰੋ

ਵੱਖ-ਵੱਖ ਗਿੱਟ ਸਟੇਜਿੰਗ ਕਮਾਂਡਾਂ ਦੇ ਉਲਝਣਾਂ ਨੂੰ ਸਮਝਣਾ ਡਿਵੈਲਪਰਾਂ ਲਈ ਬਹੁਤ ਜ਼ਰੂਰੀ ਹੈ ਜੋ ਮਲਟੀਪਲ ਸਬ-ਡਾਇਰੈਕਟਰੀਆਂ ਵਿੱਚ ਕਈ ਤਰ੍ਹਾਂ ਦੀਆਂ ਫਾਈਲਾਂ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਦੇ ਹਨ। ਜਦੋਂ ਕਿ 'ਗਿਟ ਐਡ -ਏ' ਅਤੇ 'ਗਿਟ ਐਡ' ਦੋਵੇਂ। ਤਬਦੀਲੀਆਂ ਨੂੰ ਪੜਾਅ ਦੇਣ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ, ਉਹਨਾਂ ਦੀ ਕਾਰਵਾਈ ਦਾ ਦਾਇਰਾ ਮਹੱਤਵਪੂਰਨ ਤੌਰ 'ਤੇ ਵੱਖਰਾ ਹੁੰਦਾ ਹੈ। 'git add -A' ਇੱਕ ਕਮਾਂਡ ਹੈ ਜੋ ਨਵੀਂ ਫਾਈਲਾਂ, ਸੋਧੀਆਂ ਫਾਈਲਾਂ ਅਤੇ ਮਿਟਾਈਆਂ ਫਾਈਲਾਂ ਸਮੇਤ ਪੂਰੀ ਰਿਪੋਜ਼ਟਰੀ ਵਿੱਚ ਸਾਰੀਆਂ ਤਬਦੀਲੀਆਂ ਨੂੰ ਪੜਾਅ ਦਿੰਦੀ ਹੈ। ਇਹ ਕਮਾਂਡ Git ਰਿਪੋਜ਼ਟਰੀ ਦੀ ਰੂਟ ਡਾਇਰੈਕਟਰੀ ਤੋਂ ਕੰਮ ਕਰਦੀ ਹੈ, ਟਰਮੀਨਲ ਵਿੱਚ ਮੌਜੂਦਾ ਡਾਇਰੈਕਟਰੀ ਦੀ ਪਰਵਾਹ ਕੀਤੇ ਬਿਨਾਂ।

ਦੂਜੇ ਪਾਸੇ, 'git add.' ਨਵੀਆਂ ਅਤੇ ਸੋਧੀਆਂ ਫਾਈਲਾਂ ਨੂੰ ਪੜਾਅ ਦਿੰਦਾ ਹੈ, ਪਰ ਸਿਰਫ ਮੌਜੂਦਾ ਡਾਇਰੈਕਟਰੀ ਅਤੇ ਇਸ ਦੀਆਂ ਸਬ-ਡਾਇਰੈਕਟਰੀਆਂ ਦੇ ਅੰਦਰ। ਇਸ ਵਿੱਚ ਮਿਟਾਈਆਂ ਗਈਆਂ ਫਾਈਲਾਂ ਸ਼ਾਮਲ ਨਹੀਂ ਹਨ ਜਦੋਂ ਤੱਕ ਕਿ 'git add -u' ਵਰਗੀ ਕਿਸੇ ਹੋਰ ਕਮਾਂਡ ਨਾਲ ਨਹੀਂ ਜੋੜਿਆ ਜਾਂਦਾ ਹੈ। 'git add' ਦੀ ਵਿਸ਼ੇਸ਼ਤਾ। ਇਸ ਨੂੰ ਖਾਸ ਤੌਰ 'ਤੇ ਕਿਸੇ ਪ੍ਰੋਜੈਕਟ ਦੇ ਭਾਗਾਂ ਨੂੰ ਵਧਾਉਣ ਲਈ ਲਾਭਦਾਇਕ ਬਣਾਉਂਦਾ ਹੈ, ਜੋ ਕਿ ਵੱਡੇ ਪ੍ਰੋਜੈਕਟਾਂ ਵਿੱਚ ਮਹੱਤਵਪੂਰਨ ਹੋ ਸਕਦਾ ਹੈ ਜਾਂ ਜਦੋਂ ਤਬਦੀਲੀਆਂ ਨੂੰ ਸਪੱਸ਼ਟਤਾ ਲਈ ਮਲਟੀਪਲ ਕਮਿਟਾਂ ਵਿੱਚ ਸੰਗਠਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

1. 'git add -A' ਕੀ ਕਰਦਾ ਹੈ?
2. ਸਾਰੀ ਰਿਪੋਜ਼ਟਰੀ ਵਿੱਚ ਸਾਰੀਆਂ ਤਬਦੀਲੀਆਂ (ਨਵੀਆਂ, ਸੋਧੀਆਂ ਅਤੇ ਮਿਟਾਈਆਂ ਗਈਆਂ ਫਾਈਲਾਂ) ਨੂੰ ਪੜਾਅ ਦਿੰਦਾ ਹੈ।
3. 'git ਐਡ' ਕਿਵੇਂ ਹੁੰਦਾ ਹੈ। 'git add -A' ਤੋਂ ਵੱਖਰਾ ਹੈ?
4. ਇਹ ਮਿਟਾਈਆਂ ਗਈਆਂ ਫਾਈਲਾਂ ਨੂੰ ਛੱਡ ਕੇ, ਸਿਰਫ ਮੌਜੂਦਾ ਡਾਇਰੈਕਟਰੀ ਅਤੇ ਇਸ ਦੀਆਂ ਸਬ-ਡਾਇਰੈਕਟਰੀਆਂ ਵਿੱਚ ਨਵੀਆਂ ਅਤੇ ਸੋਧੀਆਂ ਫਾਈਲਾਂ ਨੂੰ ਪੜਾਅ ਦਿੰਦਾ ਹੈ।
5. 'git add' ਕਰ ਸਕਦਾ ਹੈ। ਸਟੇਜ ਮਿਟਾਈਆਂ ਗਈਆਂ ਫਾਈਲਾਂ?
6. ਨਹੀਂ, 'git add.' ਮਿਟਾਈਆਂ ਗਈਆਂ ਫਾਈਲਾਂ ਨੂੰ ਸਟੇਜ ਨਹੀਂ ਕਰਦਾ. ਮੌਜੂਦਾ ਡਾਇਰੈਕਟਰੀ ਵਿੱਚ 'git add -u' ਦੀ ਵਰਤੋਂ ਸਟੇਜ ਮਿਟਾਉਣ ਲਈ ਕਰੋ।
7. ਕੀ 'git add -A' ਸਾਰੇ ਦ੍ਰਿਸ਼ਾਂ ਲਈ ਸਭ ਤੋਂ ਵਧੀਆ ਵਿਕਲਪ ਹੈ?
8. ਜ਼ਰੂਰੀ ਨਹੀਂ; ਇਹ ਇਸ ਗੱਲ 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ ਕਿ ਕੀ ਤੁਹਾਨੂੰ ਪੂਰੀ ਰਿਪੋਜ਼ਟਰੀ ਵਿੱਚ ਤਬਦੀਲੀਆਂ ਕਰਨ ਦੀ ਲੋੜ ਹੈ ਜਾਂ ਇਸਦੇ ਇੱਕ ਖਾਸ ਖੇਤਰ ਵਿੱਚ।
9. ਮੈਨੂੰ ਕੀ ਵਰਤਣਾ ਚਾਹੀਦਾ ਹੈ ਜੇਕਰ ਮੈਂ ਸਿਰਫ਼ ਆਪਣੀਆਂ ਤਬਦੀਲੀਆਂ ਦਾ ਹਿੱਸਾ ਬਣਾਉਣਾ ਚਾਹੁੰਦਾ ਹਾਂ?
10. 'git add' ਦੀ ਵਰਤੋਂ ਕਰੋ। ਜਾਂ 'git add ਨਾਲ ਵਿਅਕਤੀਗਤ ਫਾਈਲਾਂ ਨੂੰ ਨਿਸ਼ਚਿਤ ਕਰੋ

ਗਿੱਟ ਸਟੇਜਿੰਗ ਕਮਾਂਡਾਂ 'ਤੇ ਚਰਚਾ ਦੌਰਾਨ, ਇਹ ਸਪੱਸ਼ਟ ਹੈ ਕਿ 'ਗਿਟ ਐਡ -ਏ' ਅਤੇ 'ਗਿਟ ਐਡ'। ਵੱਖ-ਵੱਖ ਸਟੇਜਿੰਗ ਲੋੜਾਂ ਮੁਤਾਬਕ ਵੱਖਰੇ ਉਦੇਸ਼ਾਂ ਦੀ ਪੂਰਤੀ ਕਰੋ। 'git add -A' ਰਿਪੋਜ਼ਟਰੀ ਵਿੱਚ ਸਾਰੀਆਂ ਤਬਦੀਲੀਆਂ ਨੂੰ ਪੜਾਅਵਾਰ ਬਣਾ ਕੇ ਇੱਕ ਵਿਆਪਕ ਪਹੁੰਚ ਪੇਸ਼ ਕਰਦਾ ਹੈ, ਇਸਨੂੰ ਗਲੋਬਲ ਅੱਪਡੇਟ ਲਈ ਆਦਰਸ਼ ਬਣਾਉਂਦਾ ਹੈ। ਇਸ ਦੇ ਉਲਟ, 'git add.' ਸਿਰਫ਼ ਮੌਜੂਦਾ ਡਾਇਰੈਕਟਰੀ ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਕਰਕੇ ਸ਼ੁੱਧਤਾ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ, ਵਾਧੇ ਵਾਲੇ ਅੱਪਡੇਟ ਲਈ ਢੁਕਵਾਂ। ਇਹਨਾਂ ਕਮਾਂਡਾਂ ਨੂੰ ਸਮਝਣਾ ਸਟੀਕ ਅਤੇ ਪ੍ਰਭਾਵੀ ਸੰਸਕਰਣ ਨਿਯੰਤਰਣ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ, ਸਫਲ ਸੌਫਟਵੇਅਰ ਵਿਕਾਸ ਪ੍ਰੋਜੈਕਟਾਂ ਦਾ ਆਧਾਰ ਪੱਥਰ।