ਕਿਸ ਤਰ੍ਹਾਂ ਲਿਖੀਏ ਕਿ ਬੈਸ ਕਦ ਹੈ - ਲੂਪਸ

ਕਮਾਂਡਾਂ, ਸੰਟੈਕਸ ਅਤੇ ਉਦਾਹਰਨਾਂ

ਤੁਸੀਂ ਇੱਕ ਸਕਰਿਪਟ ਫਾਈਲ ਵਿੱਚ ਲਿਖ ਕੇ ਅਤੇ ਫਿਰ ਇਸਨੂੰ ਚਲਾਉਂਦੇ ਹੋਏ ਇੱਕ ਆਦੇਸ਼ਾਂ ਨੂੰ ਲੜੀਬੱਧ ਕਰ ਸਕਦੇ ਹੋ.

ਇੱਕ ਸਕਰਿਪਟ ਫਾਇਲ ਬਸ ਇੱਕ ਪਾਠ ਫਾਇਲ ਹੁੰਦੀ ਹੈ, ਆਮ ਤੌਰ ਤੇ .SH ਫਾਇਲ ਐਕਸਟੈਂਸ਼ਨ ਦੇ ਨਾਲ, ਜਿਸ ਵਿੱਚ ਹਦਾਇਤਾਂ ਦੀ ਲੜੀ ਹੁੰਦੀ ਹੈ ਜੋ ਕਮਾਂਡ ਲਾਈਨ ( ਸ਼ੈੱਲ ) ਤੋਂ ਵੀ ਲਾਗੂ ਹੁੰਦੀਆਂ ਹਨ.

ਲੂਪ ਦੀਆਂ ਉਦਾਹਰਣਾਂ

ਹੇਠਾਂ ਇੱਕ ਲੂਪ ਦੀ ਉਦਾਹਰਨ ਹੈ. ਜਦੋਂ ਐਕਜ਼ੀਕਿਯੂਟ ਹੋਏਗਾ, ਤਾਂ ਇਹ ਸਕਰਿਪਟ ਫਾਇਲ ਸਕਰੀਨ ਤੇ ਨੰਬਰ 1 ਤੋਂ 9 ਪ੍ਰਿੰਟ ਕਰੇਗੀ. ਜਦਕਿ- ਬਿਆਨ ਤੁਹਾਨੂੰ -ਲੌਪ ਦੀ ਬਜਾਏ ਸਮਾਪਤੀ ਸਥਿਤੀ ਨੂੰ ਸਪਸ਼ਟ ਕਰਨ ਲਈ ਵਧੇਰੇ ਲਚਕਤਾ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ .

#! / bin / bash ਗਿਣਤੀ = 1 ਜਦੋਂ ਕਿ [$ count -le 9] ਕੀ "$ count" sleep 1 ਈਕੋ ((++) (ਗਿਣਤੀ (++)) ਕੀਤਾ ਹੈ

ਉਦਾਹਰਨ ਲਈ, ਤੁਸੀਂ ਪਿਛਲੀ ਸਕਰਿਪਟ ਨੂੰ ਇੰਕ੍ਰਿਪਸ਼ਨ ਸਟੇਟਮੈਂਟ "((count ++))" ਨੂੰ ਛੱਡ ਕੇ ਇੱਕ ਅਨੰਤ ਲੂਪ ਬਣਾ ਸਕਦੇ ਹੋ: "

#! / bin / bash ਗਿਣਤੀ = 1 ਜਦੋਂ [$ count -le 9] ਕੀ "$ count" ਸੋਧੀ 1 ਐੱਕੋ ਕਰਦੇ ਹਾਂ

"ਸਲੀਪ 1" ਬਿਆਨ ਹਰ ਇਕ ਦੂਜੇ ਦੇ ਚੱਲਣ ਤੇ 1 ਸਕਿੰਟ ਲਈ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਨੂੰ ਰੋਕਦਾ ਹੈ. ਕਾਰਜ ਖਤਮ ਕਰਨ ਲਈ Ctrl + C ਕੀਬੋਰਡ ਸ਼ਾਰਟਕੱਟ ਦੀ ਵਰਤੋਂ ਕਰੋ.

ਤੁਸੀਂ ਕੰਡੀਸ਼ਨ ਨੂੰ ਸ਼ਰਤ ਵਜੋਂ ਪਾ ਕੇ ਅਨੰਤ ਲੂਪ ਵੀ ਬਣਾ ਸਕਦੇ ਹੋ:

#! / bin / bash ਗਿਣਤੀ = 1 ਜਦੋਂ: ਕਰਦੇ ਹਾਂ "$ count" sleep 1 ((count ++)) ਨੂੰ ਐੱਕੋ ਕੀਤਾ ਗਿਆ

ਜਦੋਂ-ਲੂਪ ਵਿੱਚ ਬਹੁਤੀਆਂ ਸ਼ਰਤਾਂ ਵਰਤਣ ਲਈ, ਤੁਹਾਨੂੰ ਡਬਲ ਵਰਗ ਬ੍ਰੈਕਟ ਬ੍ਰੈਕੇਟ ਨਾਪਣਾ ਦੀ ਵਰਤੋਂ ਕਰਨੀ ਪਵੇਗੀ:

ਗਿਣਤੀ = 1 ਕੀਤੀ = 0 ਜਦੋਂ [[$ count -le 9] ਅਤੇ& [$ done == 0]] "$ count" sleep 1 ਨੂੰ ਈਕੋ ਕਰੋ ((count ++)) ਜੇ [$ count == 5]; ਤਦ $ ਕੀਤੇ = 1 ਫਾਈ

ਇਸ ਸਕਰਿਪਟ ਵਿੱਚ, "ਪੂਰੀ ਕੀਤੀ" ਵੇਰੀਏਬਲ ਨੂੰ 0 ਤੇ ਸ਼ੁਰੂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਅਤੇ ਫਿਰ ਜਦੋਂ 1 ਗਿਣਿਆ ਜਾਂਦਾ ਹੈ ਤਾਂ 1 ਤੇ ਸੈੱਟ ਕੀਤਾ ਜਾਂਦਾ ਹੈ. ਲੂਪ ਸਥਿਤੀ ਦੱਸਦਾ ਹੈ ਕਿ ਜਦੋਂ ਕਿ ਲੂਪ "ਗਿਣਤੀ" ਨੌਂ ਤੋਂ ਘੱਟ ਹੈ ਅਤੇ "ਕੀਤਾ" ਬਰਾਬਰ ਹੁੰਦਾ ਹੈ ਜ਼ੀਰੋ ਇਸ ਲਈ ਜਦੋਂ ਲੂਪ 5 ਦੀ ਗਣਨਾ ਕਰਦਾ ਹੈ ਤਾਂ ਨਿਕਾਸ ਆਊਟ ਹੋ ਜਾਂਦਾ ਹੈ.

"&&" ਦਾ ਮਤਲਬ ਤਰਕ ਹੈ "ਅਤੇ" ਅਤੇ "||" ਲਾਜ਼ੀਕਲ ਦਾ ਮਤਲਬ "ਜਾਂ".

ਕੰਨੈਕਸ਼ਨਾਂ "ਅਤੇ" ਅਤੇ "ਜਾਂ" ਸਥਿਤੀਆਂ ਲਈ ਇੱਕ ਬਦਲਵਾਂ ਸੰਕੇਤ "-ਅ" ਅਤੇ "-ਓ" ਇੱਕ ਸਿੰਗਲ ਵਰਗ ਬ੍ਰੈਕੇਟ ਨਾਲ ਹੈ. ਉਪਰੋਕਤ ਸ਼ਰਤ:

[[$ count -le 9] && [$ done == 0]]

... ਨੂੰ ਇਸ ਤਰਾਂ ਲਿਖਿਆ ਜਾ ਸਕਦਾ ਹੈ:

[$ count -le 9] -ਅਤੇ [$ done == 0]

ਇੱਕ ਪਾਠ ਫਾਇਲ ਨੂੰ ਪੜ੍ਹਨਾ ਅਕਸਰ ਘੁੰਮਣ ਵਿੱਚ ਲੂਪ ਹੁੰਦਾ ਹੈ. ਨਿਮਨ ਲਿਖੇ ਉਦਾਹਰਣ ਵਿੱਚ, "ਸ੍ਵੈਸਟਰੀ. Txt:" ਨਾਮ ਦੀ ਇੱਕ ਫਾਈਲ ਦੀ ਤਰਤੀਬ ਨਾਲ ਬੱਟ ਸਕ੍ਰਿਪਟ ਅੰਸ਼ ਲਾਈਨ ਨੂੰ ਪੜ੍ਹਦੀ ਹੈ.

FILE = inventory.txt exec 6

ਪਹਿਲੀ ਲਾਈਨ "ਫਾਈਲੇ" ਵੇਰੀਏਬਲ ਲਈ ਇਨਪੁਟ ਫਾਈਲ ਨਾਮ ਨਿਰਧਾਰਤ ਕਰਦੀ ਹੈ. ਦੂਜੀ ਲਾਈਨ "ਡਿਸਕਲੇਟਰ" ("3" ਅਤੇ "9" ਦੇ ਵਿਚਕਾਰ ਕੋਈ ਵੀ ਮੁੱਲ ਹੋ ਸਕਦੀ ਹੈ) ਵਿੱਚ "ਸਟੈਂਡਰਡ ਇਨਪੁਟ" ਬਚਾਉਂਦੀ ਹੈ. ਇਹ ਇਸ ਲਈ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਕਿ "ਸਟੈਂਡਰਡ ਇਨਪੁਟ" ਨੂੰ ਸਕ੍ਰਿਪਟ ਦੇ ਅੰਤ ਵਿਚ "0" ਡਿਸਕ 'ਤੇ ਪੁਨਰ ਸਥਾਪਿਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ (ਦੇਖੋ "ਸਟੇਟਮੈਂਟ ਐਕ 0 ਤੀਜੀ ਲਾਈਨ ਵਿਚ ਇੰਪੁੱਟ ਫਾਈਲ ਡਿਸਕ੍ਰਿਪਟਰ" 0, "ਜੋ ਕਿ ਵਰਤੀ ਜਾਂਦੀ ਹੈ ਸਟੈਂਡਰਡ ਇੰਪੁੱਟ ਲਈ. "ਰੀਡ" ਕਥਨ ਫੇਰ ਹਰ ਇਕ ਆਵਾਜਾਈ ਤੇ ਫਾਈਲ ਵਿੱਚੋਂ ਇੱਕ ਲਾਈਨ ਪੜ੍ਹਦਾ ਹੈ ਅਤੇ ਇਸਨੂੰ "ਲਾਈਨ 1" ਵੇਰੀਏਬਲ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ.

ਅਚਾਨਕ ਇੱਕ ਸਮੇਂ-ਲੂਪ ਤੋਂ ਬਾਹਰ ਜਾਣ ਲਈ, ਤੁਸੀਂ ਇਸ ਤਰ੍ਹਾਂ ਦੇ ਬਰੇਕ ਕਥਨ ਨੂੰ ਵਰਤ ਸਕਦੇ ਹੋ:

count = 1 done = 0 ਜਦੋਂ ਕਿ [$ count -le 9] "$ count" sleep 1 ((count ++)) ਨੂੰ ਐੱਕੋ ਕਰਦੇ ਹੋ, ਜੇ [$ count == 5] ਫਿਰ ਫ੍ਰੀ ਐਕ੍ਕੋ ਐਕੋ ਖਤਮ ਕਰੋ

ਬਰੇਕ ਸਟੇਟਮੈਂਟ ਦੇ ਅੰਤ ਵਿੱਚ ਪ੍ਰੋਗਰਾਮ ਐਕਜ਼ੀਕਿਯੂਸ਼ਨ ਨੂੰ ਛੱਡ ਦਿੰਦਾ ਹੈ ਅਤੇ ਇਸਦੇ ਬਾਅਦ ਕਿਸੇ ਵੀ ਸਟੇਟਮੈਂਟ ਨੂੰ ਚਲਾਉਂਦਾ ਹੈ. ਇਸ ਕੇਸ ਵਿੱਚ, ਸਟੇਟਮੈਂਟ "ਈਕੋ ਫਾਈਨਿੰਗ."

ਦੂਜੇ ਪਾਸੇ, ਜਾਰੀ ਬਿਆਨ, ਮੌਜੂਦਾ ਰੀਟੇਨਿੰਗ ਦੇ ਬਾਕੀ ਦੇ ਲੂਪ ਸਟੇਟਮੈਂਟ ਨੂੰ ਛੱਡ ਦਿੰਦਾ ਹੈ ਅਤੇ ਸਿੱਧਾ ਅਗਲਾ ਦੁਹਰਾਈ ਨਾਲ ਸਿੱਧਾ ਚਲੇ ਜਾਂਦਾ ਹੈ:

count = 1 done = 0 ਜਦੋਂ [$ count -le 9] ਸਲੀਪ ਕਰੋ 1 ((count ++)) ਜੇ [$ count == 5] ਤਾਂ ਫਿਰ "$ count" ਨੂੰ ਐੱਕੋ ਕਰੋ, ਈਕੋ ਮੁਕੰਮਲ ਹੋਇਆ.

ਇਸ ਸਥਿਤੀ ਵਿੱਚ, "ਜਾਰੀ" ਬਿਆਨ ਉਦੋਂ ਲਾਗੂ ਹੁੰਦਾ ਹੈ ਜਦੋਂ ਵੇਰੀਏਬਲ "ਗਿਣਤੀ" 5 ਤੱਕ ਪਹੁੰਚਦਾ ਹੈ. ਇਸ ਦਾ ਮਤਲਬ ਹੈ ਕਿ ਇਸ ਦੁਹਰਾਓ ("ਗਿਣਤੀ" ਦਾ ਮੁੱਲ 5 ਹੈ) ਤੇ ਬਾਅਦ ਦੇ ਵਿਵਰਣ (ਈਕੋ "$ ਗਿਣਤੀ") ਨੂੰ ਲਾਗੂ ਨਹੀਂ ਕੀਤਾ ਗਿਆ ਹੈ.