ਸ਼ੁਰੂਆਤ ਗਾਈਡ ਦੇ ਤੀਜੀ ਭਾਗ ਤੇ ਸੁਆਗਤ ਹੈ BASH ਸੀਰੀਜ਼ ਜਿਸ ਵਿੱਚ ਵਿਲੱਖਣ ਹੈ ਕਿ ਇਹ ਸ਼ੁਰੂਆਤ ਕਰਨ ਵਾਲਿਆਂ ਲਈ ਇੱਕ ਸ਼ੁਰੂਆਤੀ ਦੁਆਰਾ ਲਿਖਿਆ ਇਕੋ-ਇਕ ਬਸ ਬਸ ਟਯੂਟੋਰਿਅਲ ਹੈ.
ਇਸ ਗਾਈਡ ਦੇ ਪਾਠਕ ਆਪਣੀ ਜਾਣਕਾਰੀ ਨੂੰ ਵਧਾਉਂਦੇ ਹਨ ਜਿਵੇਂ ਮੈਂ ਆਪਣਾ ਗਿਆਨ ਬਣਾਉਂਦਾ ਹਾਂ ਅਤੇ ਉਮੀਦ ਹੈ ਕਿ ਇਸ ਦੇ ਅੰਤ ਤੱਕ ਅਸੀਂ ਕੁਝ ਕਾਫ਼ੀ ਹੁਸ਼ਿਆਰ ਲਿਪੀਆਂ ਲਿਖਣ ਦੇ ਯੋਗ ਹੋਵਾਂਗੇ.
ਪਿਛਲੇ ਹਫ਼ਤੇ ਮੈਂ ਤੁਹਾਡੀ ਪਹਿਲੀ ਸਕ੍ਰਿਪਟ ਨੂੰ ਕਵਰ ਕੀਤਾ ਹੈ ਜਿਸ ਵਿੱਚ ਸ਼ਬਦ "ਹੈਲੋ ਵਿਸ਼ਵ" ਹੈ. ਇਹ ਟੈਕਸਟ ਐਡੀਟਰਾਂ, ਟਰਮਿਨਲ ਵਿੰਡੋ ਕਿਵੇਂ ਖੋਲ੍ਹਣਾ ਹੈ, ਆਪਣੀ ਸਕ੍ਰਿਪਟ ਕਿੱਥੇ ਪਾਉਣਾ ਹੈ, "ਹੈਲੋ ਵਰਲਡ" ਸ਼ਬਦ ਨੂੰ ਕਿਵੇਂ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨਾ ਹੈ ਅਤੇ ਕਿੱਸੇ ("") ਜਿਵੇਂ ਕਿ ਬਚਣ ਵਾਲੇ ਅੱਖਰ ਤੇ ਕੁਝ ਵਧੀਆ ਅੰਕ ਕਿਵੇਂ ਦਿਖਾਉਂਦੇ ਹਨ.
ਇਸ ਹਫ਼ਤੇ ਮੈਂ ਇਨਪੁਟ ਪੈਰਾਮੀਟਰਾਂ ਨੂੰ ਕਵਰ ਕਰਨ ਜਾ ਰਿਹਾ ਹਾਂ. ਹੋਰ ਗਾਈਡ ਵੀ ਹਨ ਜੋ ਇਸ ਕਿਸਮ ਦੀ ਸਿੱਖਿਆ ਦਿੰਦੇ ਹਨ ਪਰ ਮੈਨੂੰ ਪਤਾ ਲੱਗਦਾ ਹੈ ਕਿ ਉਹ ਕੁਝ ਨੀਵੀਂ ਪੱਧਰ ਦੀਆਂ ਚੀਜ਼ਾਂ ਵਿਚ ਚਲੇ ਜਾਂਦੇ ਹਨ ਅਤੇ ਸ਼ਾਇਦ ਬਹੁਤ ਜ਼ਿਆਦਾ ਜਾਣਕਾਰੀ ਪ੍ਰਦਾਨ ਕਰਦੇ ਹਨ.
ਇਕ ਪੈਰਾਮੀਟਰ ਕੀ ਹੈ?
ਆਖਰੀ ਟਿਊਟੋਰਿਅਲ ਤੋਂ "ਹੈਲੋ ਵਿਸ਼ਵ" ਸਕਰਿਪਟ ਵਿਚ ਇਹ ਸਭ ਬਹੁਤ ਸਥਿਰ ਸੀ. ਸਕਰਿਪਟ ਅਸਲ ਵਿੱਚ ਬਹੁਤ ਕੁਝ ਨਹੀਂ ਕਰਦੀ ਸੀ.
ਅਸੀਂ "ਹੈਲੋ ਵਿਸ਼ਵ" ਸਕ੍ਰਿਪਟ ਤੇ ਕਿਵੇਂ ਸੁਧਾਰ ਕਰ ਸਕਦੇ ਹਾਂ?
ਉਸ ਸਕ੍ਰਿਪਟ ਬਾਰੇ ਕੀ ਹੈ ਜੋ ਇਸਨੂੰ ਚਲਾਉਂਦਾ ਹੈ? "ਹੇਲੋ ਵਰਲਡ" ਕਹਿਣ ਦੀ ਬਜਾਏ ਇਹ "ਹੈਲੋ ਗੈਰੀ", "ਹੈਲੋ ਟਿਮ" ਜਾਂ "ਹੈਲੋ ਡਾਲੀ" ਕਹਿਣਗੇ.
ਇੰਪੁੱਟ ਪੈਰਾਮੀਟਰ ਨੂੰ ਸਵੀਕਾਰ ਕਰਨ ਦੀ ਸਮਰੱਥਾ ਤੋਂ ਬਿਨਾਂ ਸਾਨੂੰ "hellogary.sh", "hellotim.sh" ਅਤੇ "hellodolly.sh" ਦੀਆਂ ਤਿੰਨ ਸਕਰਿਪਟ ਲਿਖਣ ਦੀ ਜ਼ਰੂਰਤ ਹੈ.
ਸਾਡੀ ਸਕਰਿਪਟ ਨੂੰ ਇਨਪੁਟ ਪੈਰਾਮੀਟਰ ਪੜ੍ਹਨ ਦੀ ਇਜ਼ਾਜਤ ਦੇ ਕੇ ਅਸੀਂ ਕਿਸੇ ਨੂੰ ਵੀ ਨਮਸਕਾਰ ਕਰਨ ਲਈ ਇਕ ਲਿਪੀ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹਾਂ
ਅਜਿਹਾ ਕਰਨ ਲਈ ਇੱਕ ਟਰਮੀਨਲ ਵਿੰਡੋ ਨੂੰ ਖੋਲ੍ਹਣ ਲਈ (CTRL + ALT + T) ਅਤੇ ਆਪਣੀ ਸਕ੍ਰਿਪਟ ਫੋਲਡਰ ਨੂੰ ਹੇਠ ਲਿਖੇ ਟਾਈਪ ਕਰਕੇ ਨੈਵੀਗੇਟ ਕਰੋ: ( cd ਕਮਾਂਡ ਬਾਰੇ )
ਸੀ ਡੀ ਸਕ੍ਰਿਪਟਾਂਹੇਠ ਲਿਖਿਆਂ ਨੂੰ ਇਕ ਨਵੇਂ ਸਕ੍ਰਿਪਟ ਬਣਾਓ ਜਿਸਦਾ ਨਾਂ ਹੈ "greetme.sh" ( ਟਚ ਕਮਾਂਡ ਬਾਰੇ )
ਛੂਹੋ greetme.shਹੇਠ ਲਿਖੇ ਟਾਈਪ ਕਰਕੇ ਆਪਣੀ ਪਸੰਦੀਦਾ ਐਡੀਟਰ ਵਿੱਚ ਸਕ੍ਰਿਪਟ ਖੋਲ੍ਹੋ: ( ਨੈਨੋ ਕਮਾਂਡ ਬਾਰੇ )
ਨੈਨੋ ਜੀਹੇਠ ਲਿਖੇ ਪਾਠ ਨੂੰ ਨੈਨੋ ਦੇ ਅੰਦਰ ਦਰਜ ਕਰੋ:
#! / bin / bash echo "ਹੈਲੋ $ @"ਫਾਈਲ ਨੂੰ ਸੇਵ ਕਰਨ ਲਈ CTRL ਅਤੇ O ਪ੍ਰੈੱਸ ਕਰੋ ਅਤੇ ਫਿਰ ਫਾਈਲ ਨੂੰ ਬੰਦ ਕਰਨ ਲਈ CTRL ਅਤੇ X
ਸਕ੍ਰਿਪਟ ਚਲਾਉਣ ਲਈ, ਹੇਠ ਲਿਖੀ ਕਮਾਂਡ ਲਾਈਨ ਵਿੱਚ ਆਪਣੇ ਨਾਂ ਨਾਲ ਦਾਖਲ ਹੋਵੋ.
sh greetme.shਜੇ ਮੈਂ ਸਕ੍ਰਿਪਟ ਆਪਣੇ ਨਾਂ ਨਾਲ ਚਲਾਉਂਦਾ ਹਾਂ ਤਾਂ ਇਹ "ਹੈਲੋ ਗੈਰੀ" ਸ਼ਬਦ ਦਰਸਾਉਂਦਾ ਹੈ.
ਪਹਿਲੀ ਲਾਈਨ ਵਿੱਚ #! / Bin / bash ਲਾਈਨ ਹੈ, ਜੋ ਕਿ ਫਾਇਲ ਨੂੰ bash ਸਕ੍ਰਿਪਟ ਵਜੋਂ ਪਛਾਣ ਕਰਨ ਲਈ ਵਰਤੀ ਜਾਂਦੀ ਹੈ.
ਦੂਜੀ ਲਾਇਨ ਹੇਲੋ ਸ਼ਬਦ ਨੂੰ ਐਕੋ ਕਰਨ ਲਈ ਈਕੋ ਸਟੇਟਮੈਂਟ ਦੀ ਵਰਤੋਂ ਕਰਦੀ ਹੈ ਅਤੇ ਫਿਰ ਅਜੀਬ $ @ ਨੋਟੇਸ਼ਨ ਹੈ. ( ਈਕੋ ਕਮਾਂਡ ਬਾਰੇ )
$ @ ਸਕ੍ਰਿਪਟ ਨਾਮ ਦੇ ਨਾਲ ਦਰਜ ਕੀਤੇ ਗਏ ਹਰ ਪੈਰਾਮੀਟਰ ਨੂੰ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨ ਲਈ ਫੈਲਾਉਂਦਾ ਹੈ ਇਸ ਲਈ ਜੇ ਤੁਸੀਂ "sh greetme.sh tim" ਟਾਈਪ ਕੀਤਾ ਹੈ ਤਾਂ "ਹੈਲੋ ਟਾਈ" ਸ਼ਬਦ ਦਰਸਾਏ ਜਾਣਗੇ. ਜੇ ਤੁਸੀਂ "greetme.sh tim smith" ਟਾਈਪ ਕਰਦੇ ਹੋ ਤਾਂ "ਹੈਲੋ ਟੌਮ ਸਮਿੱਥ" ਸ਼ਬਦ ਦਰਸਾਏ ਜਾਣਗੇ.
ਇਹ ਕੇਵਲ ਨਮਸਤੇ ਦਾ ਇਸਤੇਮਾਲ ਕਰਕੇ ਹੈਲੋ ਨੂੰ ਕਹਿਣ ਲਈ greetme.sh ਸਕਰਿਪਟ ਲਈ ਚੰਗਾ ਹੋ ਸਕਦਾ ਹੈ. ਜਦੋਂ ਕੋਈ ਮੈਨੂੰ ਮਿਲਦਾ ਹੈ ਤਾਂ ਕੋਈ ਵੀ "ਹੈਲੋ ਗੈਰੀ ਨੇell" ਨਹੀਂ ਕਹਿੰਦਾ ਹੈ, ਪਰ ਉਹ "ਹੈਲੋ ਗੈਰੀ" ਕਹਿ ਸਕਦੇ ਹਨ.
ਆਉ ਸਕ੍ਰਿਪਟ ਨੂੰ ਬਦਲ ਦੇਈਏ ਤਾਂ ਕਿ ਇਹ ਸਿਰਫ ਪਹਿਲੇ ਪੈਰਾਮੀਟਰ ਦੀ ਵਰਤੋਂ ਕਰੇ. ਹੇਠ ਲਿਖੇ ਟਾਈਪ ਕਰਕੇ ਨੈਨੋ ਵਿੱਚ ਸਲੈਟ ਕਰੋ:
ਨੈਨੋ ਜੀਸਕ੍ਰਿਪਟ ਨੂੰ ਬਦਲੋ ਤਾਂ ਕਿ ਇਹ ਇਸ ਤਰਾਂ ਲਿਖਿਆ ਜਾਵੇ:
#! / bin / bash ਈਕੋ "ਹੈਲੋ $ 1"CTRL ਅਤੇ O ਦਬਾ ਕੇ ਸਕ੍ਰਿਪਟ ਸੇਵ ਕਰੋ ਅਤੇ ਫਿਰ CTRL ਅਤੇ X ਦਬਾ ਕੇ ਬਾਹਰ ਜਾਓ
ਹੇਠਾਂ ਦਿਖਾਇਆ ਗਿਆ ਸਕ੍ਰਿਪਟ ਚਲਾਓ (ਤੁਹਾਡੇ ਨਾਲ ਮੇਰਾ ਨਾਂ ਬਦਲੋ):
sh greetme.sh ਗੈਰੀ ਨਿਊਲਜਦੋਂ ਤੁਸੀਂ ਸਕ੍ਰਿਪਟ ਚਲਾਉਂਦੇ ਹੋ ਤਾਂ ਇਹ ਬਸ "ਹੈਲੋ ਗੈਰੀ" (ਜਾਂ ਉਮੀਦ ਹੈ ਕਿ "ਹੈਲੋ" ਅਤੇ ਜੋ ਵੀ ਤੇਰਾ ਨਾਮ ਹੈ) ਕਹਿਣਗੇ.
$ Symbol ਦੇ ਬਾਅਦ 1 ਮੂਲ ਰੂਪ ਵਿੱਚ echo ਕਮਾਂਡ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ, ਪਹਿਲੇ ਪੈਰਾਮੀਟਰ ਦਾ ਇਸਤੇਮਾਲ ਕਰੋ. ਜੇ ਤੁਸੀਂ $ 2 ਨੂੰ $ 2 ਨਾਲ ਬਦਲਦੇ ਹੋ ਤਾਂ ਇਹ "ਹੈਲੋ ਨਿਊਏਲ" (ਜਾਂ ਜੋ ਵੀ ਤੁਹਾਡਾ ਉਪਨਾਮ ਹੈ) ਨੂੰ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰੇਗਾ.
ਇਤਫਾਕਨ ਜੇ ਤੁਸੀਂ $ 2 ਨੂੰ $ 3 ਦੇ ਨਾਲ ਬਦਲ ਦਿੱਤਾ ਹੈ ਅਤੇ ਸਿਰਫ 2 ਪੈਰਾਮੀਟਰਾਂ ਨਾਲ ਸਕ੍ਰਿਪਟ ਚਲਾਉਂਦੇ ਹੋ ਤਾਂ ਆਉਟਪੁੱਟ ਸਿਰਫ "ਹੈਲੋ" ਹੋਵੇਗੀ.
ਅਸਲ ਵਿੱਚ ਦਿੱਤੇ ਗਏ ਪੈਰਾਮੀਟਰਾਂ ਦੀ ਗਿਣਤੀ ਨੂੰ ਵੇਖਾਉਣਾ ਅਤੇ ਹੈਂਡਲ ਕਰਨਾ ਸੰਭਵ ਹੈ ਅਤੇ ਬਾਅਦ ਵਿੱਚ ਟਿਊਟੋਰਿਅਲ ਵਿੱਚ ਮੈਂ ਦਿਖਾ ਰਿਹਾ ਹਾਂ ਕਿ ਪ੍ਰਮਾਣਿਕਤਾ ਦੇ ਉਦੇਸ਼ਾਂ ਲਈ ਪੈਰਾਮੀਟਰ ਦੀ ਗਿਣਤੀ ਕਿਵੇਂ ਵਰਤੀ ਜਾਏ.
ਵਰਤੇ ਗਏ ਮਾਪਦੰਡਾਂ ਦੀ ਗਿਣਤੀ ਨੂੰ ਦਰਸਾਉਣ ਲਈ greetme.sh ਸਕਰਿਪਟ (ਨੈਨੋ ਜੀਟਸਮੇਸ.ਸ.) ਨੂੰ ਖੋਲ੍ਹੋ ਅਤੇ ਹੇਠਾਂ ਦਿੱਤੇ ਪਾਠ ਵਿੱਚ ਸੋਧ ਕਰੋ:
#! / bin / bash echo "ਤੁਸੀਂ $ # ਨਾਂ ਦਾਖਲ ਕੀਤੇ ਹਨ" ਈਕੋ "ਹੈਲੋ $ @"ਨੈਨੋ ਤੋਂ ਬਾਹਰ ਆਉਣ ਲਈ ਸਕ੍ਰਿਪਟ ਅਤੇ CTRL ਅਤੇ X ਨੂੰ ਬਚਾਉਣ ਲਈ CTRL ਅਤੇ O ਦਬਾਓ.
ਦੂਜੀ ਲਾਈਨ 'ਤੇ $ # ਦਾਖਲ ਕੀਤੇ ਪੈਰਾਮੀਟਰ ਦੀ ਗਿਣਤੀ ਦਰਸਾਉਂਦਾ ਹੈ.
ਇਸ ਤੋਂ ਹੁਣ ਤੱਕ ਇਹ ਸਭ ਕੁਝ ਨਵਾਂ ਨਹੀਂ ਹੈ ਪਰ ਬਹੁਤ ਉਪਯੋਗੀ ਹੈ. ਕਿਸ ਨੂੰ ਇੱਕ ਸਕਰਿਪਟ ਦੀ ਲੋੜ ਹੈ ਜੋ ਕੇਵਲ "ਹੈਲੋ" ਪ੍ਰਦਰਸ਼ਤ ਕਰਦੀ ਹੈ?
ਈਕੋ ਸਟੇਟਮੈਂਟ ਲਈ ਅਸਲ ਵਰਤੋਂ ਯੂਜ਼ਰ ਨੂੰ ਵਰਬੋਸ ਅਤੇ ਅਰਥਪੂਰਨ ਆਉਟਪੁਟ ਪ੍ਰਦਾਨ ਕਰਨਾ ਹੈ. ਜੇ ਤੁਸੀਂ ਕਲਪਨਾ ਕਰ ਸਕਦੇ ਹੋ ਕਿ ਤੁਸੀਂ ਕੁਝ ਅਜਿਹਾ ਜਟਿਲ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ ਜਿਸ ਵਿੱਚ ਕੁੱਝ ਗੰਭੀਰ ਸੰਖਿਆਵਾਂ ਅਤੇ ਫਾਇਲ / ਫੋਲਡਰ ਦੀ ਹੇਰਾਫੇਰੀ ਸ਼ਾਮਲ ਹੁੰਦੀ ਹੈ, ਤਾਂ ਉਪਯੋਗਕਰਤਾ ਨੂੰ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨਾ ਲਾਭਦਾਇਕ ਹੋਵੇਗਾ ਕਿ ਰਾਹ ਵਿੱਚ ਹਰ ਇੱਕ ਕਦਮ ਕੀ ਹੋ ਰਿਹਾ ਹੈ.
ਇਸਦੇ ਉਲਟ, ਇਨਪੁਟ ਪੈਰਾਮੀਟਰਾਂ ਦੁਆਰਾ ਤੁਹਾਡੀ ਸਕ੍ਰਿਪਟ ਇੰਟਰੈਕਟਿਵ ਬਣਦੀ ਹੈ ਇੰਪੁੱਟ ਪੈਰਾਮੀਟਰਾਂ ਦੇ ਬਿਨਾਂ ਤੁਹਾਨੂੰ ਡਰਾਉਣੀਆਂ ਸਕਰਿਪਟਾਂ ਦੀ ਜ਼ਰੂਰਤ ਹੁੰਦੀ ਹੈ ਜੋ ਸਾਰੇ ਇੱਕੋ ਜਿਹੀਆਂ ਗੱਲਾਂ ਕਰਦੇ ਹਨ ਪਰ ਥੋੜ੍ਹੇ ਜਿਹੇ ਵੱਖਰੇ ਨਾਮਾਂ ਨਾਲ.
ਇਸ ਸਾਰੇ ਦੇ ਮੱਦੇਨਜ਼ਰ ਇੱਥੇ ਕੁਝ ਹੋਰ ਉਪਯੋਗੀ ਇੰਪੁਆਇੰਟ ਮਾਪਦੰਡ ਹਨ ਜੋ ਇਹ ਜਾਣਨ ਲਈ ਇੱਕ ਵਧੀਆ ਵਿਚਾਰ ਹੈ ਅਤੇ ਮੈਂ ਉਹਨਾਂ ਨੂੰ ਇੱਕ ਕੋਡ ਸਨਿੱਪਟ ਵਿੱਚ ਸ਼ਾਮਲ ਕਰਾਂਗਾ.
ਆਪਣੀ ਸਵਾਗਤਕਰਤਾ ਸਕਰਿਪਟ ਨੂੰ ਖੋਲੋ ਅਤੇ ਇਸ ਨੂੰ ਸੋਧੋ:
#! / bin / bash echo "ਫਾਈਲ ਦਾ ਨਾਮ: $ 0" ਈਕੋ "ਪ੍ਰਕਿਰਿਆ ID: $$" echo "---------------------------- --- "ਈਕੋ" ਤੁਸੀਂ $ # ਨਾਂ "ਐਕੋ" ਹੈਲੋ $ @ ਦਾਖਲ ਕੀਤਾ ਹੈ "ਬੰਦ ਕਰਨ ਲਈ ਫਾਈਲ ਅਤੇ CTRL ਅਤੇ X ਨੂੰ ਸੇਵ ਕਰਨ ਲਈ CTRL ਅਤੇ O ਦਬਾਉ.
ਹੁਣ ਸਕ੍ਰਿਪਟ ਚਲਾਓ (ਆਪਣੇ ਨਾਮ ਨਾਲ ਤਬਦੀਲ ਕਰੋ)
sh greetme.shਇਸ ਵਾਰ ਸਕਰਿਪਟ ਹੇਠ ਦਿੱਤਿਆਂ ਨੂੰ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਦੀ ਹੈ:
ਫਾਈਲ ਨਾਮ: greetme.sh ਪ੍ਰਕਿਰਿਆ ID: 18595 ------------------------------ ਤੁਸੀਂ 2 ਨਾਮ ਦਾਖਲ ਕੀਤੇ ਹਨ, ਹੇਲੋ ਗੈਰੀ ਨੇellਸਕ੍ਰਿਪਟ ਦੀ ਪਹਿਲੀ ਲਾਈਨ ਤੇ $ 0 ਤੁਹਾਡੇ ਦੁਆਰਾ ਚੱਲ ਰਹੇ ਸਕ੍ਰਿਪਟ ਦਾ ਨਾਮ ਦਰਸਾਉਂਦਾ ਹੈ. ਨੋਟ ਕਰੋ ਕਿ ਇਹ ਡਾਲਰ ਦਾ ਜ਼ੀਰੋ ਅਤੇ ਡਾਲਰ ਓ ਨਹੀਂ ਹੈ.
ਦੂਜੀ ਲਾਈਨ 'ਤੇ $ $ ਤੁਹਾਡੇ ਦੁਆਰਾ ਚੱਲ ਰਹੇ ਸਕਰਿਪਟ ਦੀ ਪ੍ਰਕਿਰਿਆ ਆਈਡੀ ਦਿਖਾਉਂਦਾ ਹੈ. ਇਹ ਲਾਭਦਾਇਕ ਕਿਉਂ ਹੈ? ਜੇ ਤੁਸੀਂ ਫੋਰਗਰਾਉਡ ਵਿੱਚ ਇੱਕ ਸਕ੍ਰਿਪਟ ਚਲਾ ਰਹੇ ਹੋ ਤਾਂ ਤੁਸੀਂ ਸਿਰਫ਼ CTRL ਅਤੇ C ਦਬਾ ਕੇ ਰੱਦ ਕਰ ਸਕਦੇ ਹੋ. ਜੇ ਤੁਸੀਂ ਸਕਰਿਪਟ ਨੂੰ ਬੈਕਗਰਾਊਂਡ ਵਿੱਚ ਚਲਾਉਂਦੇ ਹੋ ਅਤੇ ਇਹ ਉਸੇ ਤਰਤੀਬ ਦੀ ਸ਼ੁਰੂਆਤ ਕਰਨਾ ਸ਼ੁਰੂ ਕਰ ਦਿੱਤਾ ਹੈ ਅਤੇ ਇਹ ਉਸੇ ਤਰ੍ਹਾਂ ਕਰ ਰਿਹਾ ਹੈ ਕਿ ਤੁਸੀਂ ਆਪਣੇ ਸਿਸਟਮ ਨੂੰ ਨੁਕਸਾਨ ਪਹੁੰਚਾਉਣਾ ਚਾਹੁੰਦੇ ਹੋ ਇਸ ਨੂੰ ਮਾਰਨ ਲਈ
ਪਿੱਠਭੂਮੀ ਵਿਚ ਚੱਲ ਰਹੇ ਇਕ ਸਕ੍ਰਿਪਟ ਨੂੰ ਮਾਰਨ ਲਈ ਤੁਹਾਨੂੰ ਸਕਰਿਪਟ ਦੀ ਪ੍ਰਕਿਰਿਆ ਆਈਡੀ ਦੀ ਲੋੜ ਹੈ. ਕੀ ਇਹ ਚੰਗਾ ਨਹੀਂ ਹੁੰਦਾ ਜੇ ਸਕ੍ਰਿਪਟ ਨੇ ਆਪਣੀ ਆਉਟਪੁੱਟ ਦੇ ਹਿੱਸੇ ਦੇ ਤੌਰ ਤੇ ਪ੍ਰਕਿਰਿਆ ਆਈਡੀ ਦਿੱਤੀ? ( ps ਬਾਰੇ ਅਤੇ ਕਮਾਂਡਾਂ ਨੂੰ ਮਾਰ ਦਿਓ )
ਅੰਤ ਵਿੱਚ ਇਸ ਵਿਸ਼ੇ ਨਾਲ ਖਤਮ ਹੋਣ ਤੋਂ ਪਹਿਲਾਂ ਮੈਂ ਇਸ ਬਾਰੇ ਚਰਚਾ ਕਰਨਾ ਚਾਹੁੰਦਾ ਸੀ ਕਿ ਆਉਟਪੁੱਟ ਕਿੱਥੇ ਜਾਂਦੀ ਹੈ. ਹਰ ਵਾਰ ਸਕਰਿਪਟ ਇਸ ਤਰ੍ਹਾਂ ਚੱਲਦੀ ਹੈ ਤਾਂ ਸਕਰੀਨ ਤੇ ਆਉਟਪੁੱਟ ਪ੍ਰਦਰਸ਼ਿਤ ਹੋ ਗਈ ਹੈ.
ਸਕ੍ਰਿਪਟ ਆਉਟਪੁੱਟ ਨੂੰ ਆਉਟਪੁੱਟ ਫਾਇਲ ਵਿੱਚ ਲਿਖਣ ਲਈ ਇਹ ਆਮ ਹੈ. ਇਹ ਕਰਨ ਲਈ ਆਪਣੀ ਸਕ੍ਰਿਪਟ ਚਲਾਓ:
sh greetme.sh gary> greetme.logਉਪਰੋਕਤ ਕਮਾਂਡ ਵਿੱਚ "ਚਿੰਨ੍ਹ" ਹੈਲੋ ਗੈਰੀ "ਪਾਠ ਨੂੰ ਆਉਟਪੁੱਟ ਦਿੰਦਾ ਹੈ ਜਿਸਨੂੰ" greetme.log "ਕਹਿੰਦੇ ਹਨ.
ਹਰ ਵਾਰ ਜਦੋਂ ਤੁਸੀਂ ਸਕ੍ਰਿਪਟ ਨੂੰ> ਚਿੰਨ੍ਹ ਨਾਲ ਚਲਾਉਂਦੇ ਹੋ, ਤਾਂ ਇਹ ਆਉਟਪੁੱਟ ਫਾਇਲ ਦੀ ਸਮੱਗਰੀ ਉੱਤੇ ਲਿਖ ਦਿੰਦਾ ਹੈ. ਜੇ ਤੁਸੀਂ ਫਾਈਲ ਨੂੰ ਜੋੜਨ ਨੂੰ ਤਰਜੀਹ ਦਿੰਦੇ ਹੋ ਤਾਂ "ਨਾਲ" ਨਾਲ ਤਬਦੀਲ ਕਰੋ.
ਸੰਖੇਪ
ਤੁਹਾਨੂੰ ਹੁਣ ਸਕ੍ਰੀਨ ਤੇ ਟੈਕਸਟ ਲਿਖਣ ਅਤੇ ਇਨਪੁਟ ਪੈਰਾਮੀਟਰਾਂ ਨੂੰ ਸਵੀਕਾਰ ਕਰਨ ਦੇ ਯੋਗ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ.