ਲੂਪ ਲਈ "ਬਿਊਰੋ" ਕਿਵੇਂ ਲਿਖਣਾ ਹੈ

ਸ਼ੈੱਲ ਸਕਰਿਪਟਾਂ ਵਿੱਚ "for" ਲੂਪ ਲਈ BASH ਦੀ ਵਰਤੋਂ ਕਿਵੇਂ ਕਰੀਏ

ਬਾਸ਼ (ਜੋ ਬੌਰਨ ਦੁਬਾਰਾ ਸ਼ੈੱਲ ਲਈ ਖੜ੍ਹਾ ਹੈ) ਇੱਕ ਸਕਰਿਪਟਿੰਗ ਭਾਸ਼ਾ ਹੈ ਜੋ ਕਿ ਬਹੁਤੇ ਲੀਨਕਸ ਅਤੇ ਯੂਨੈਕਸ-ਅਧਾਰਿਤ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮਾਂ ਦੁਆਰਾ ਵਰਤੀ ਜਾਂਦੀ ਹੈ.

ਤੁਸੀਂ ਟਰਮੀਨਲ ਵਿੰਡੋ ਦੇ ਵਿੱਚਕਾਰ ਬॅश ਕਮਾਂਡ ਚਲਾ ਸਕਦੇ ਹੋ ਜਾਂ ਤੁਸੀਂ ਇੱਕ ਸ਼ੈੱਲ ਸਕ੍ਰਿਪਟ ਤਿਆਰ ਕਰਨ ਲਈ ਇੱਕ ਟੈਕਸਟ ਫਾਈਲ ਵਿੱਚ ਕਮਾਂਡਜ਼ ਨੂੰ ਜੋੜ ਸਕਦੇ ਹੋ.

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

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

ਕਿਸੇ ਵੀ ਪ੍ਰੋਗ੍ਰਾਮਿੰਗ ਅਤੇ ਸਕ੍ਰਿਪਟਿੰਗ ਭਾਸ਼ਾ ਦਾ ਮੁੱਖ ਹਿੱਸਾ ਬਾਰ ਬਾਰ ਕੋਡ ਦੇ ਉਸੇ ਹਿੱਸੇ ਨੂੰ ਚਲਾਉਣ ਦੀ ਸਮਰੱਥਾ ਹੈ.

ਕੋਡ ਨੂੰ ਦੁਹਰਾਉਣ ਦੇ ਕਈ ਤਰੀਕੇ ਹਨ (ਜਿਸ ਨੂੰ ਲੂਪਸ ਵੀ ਕਿਹਾ ਜਾਂਦਾ ਹੈ) ਇਸ ਗਾਈਡ ਵਿਚ, ਤੁਹਾਨੂੰ "for" ਲੂਪ ਨੂੰ ਕਿਵੇਂ ਲਿਖਣਾ ਹੈ ਦਿਖਾਏਗਾ.

A ਲਈ ਲੂਪ ਕੋਡ ਦੇ ਕੁਝ ਹਿੱਸੇ ਨੂੰ ਦੁਹਰਾਉਂਦਾ ਹੈ. ਉਹ ਉਪਯੋਗੀ ਹੁੰਦੇ ਹਨ ਇਸ ਲਈ ਕਿ ਇਕ ਹੁਕਮ ਦੀ ਲੜੀ ਕਿਸੇ ਖਾਸ ਸਥਿਤੀ ਨੂੰ ਪੂਰਾ ਹੋਣ ਤੱਕ ਚਲਦੀ ਰਹਿ ਸਕਦੀ ਹੈ, ਜਿਸ ਦੇ ਬਾਅਦ ਉਹ ਰੁਕ ਜਾਣਗੇ

ਇਸ ਗਾਈਡ ਵਿਚ, ਤੁਹਾਨੂੰ ਬੌਸ਼ ਲਿਪਟ ਵਿਚ ਲੂਪ ਲਈ ਪੰਜ ਤਰੀਕੇ ਵਰਤਣ ਦੇ ਤਰੀਕੇ ਦਿਖਾਏ ਜਾਣਗੇ.

ਸ਼ੁਰੂ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ

ਲੌਕ ਦੇ ਉਦਾਹਰਣਾਂ ਲਈ ਸ਼ੁਰੂ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ, ਤੁਹਾਨੂੰ ਇੱਕ ਟਰਮੀਨਲ ਵਿਂਡੋ ਖੋਲ੍ਹਣ ਅਤੇ ਇਹਨਾਂ ਕਦਮਾਂ ਦਾ ਪਾਲਣ ਕਰਨ ਦੀ ਲੋੜ ਹੈ:

1. ਐਮਕੇਡੀਆਰ ਸਕ੍ਰਿਪਟਾਂ ਦਿਓ ( ਇੱਥੇ ਐਮਕੇਡੀਆਰ ਬਾਰੇ ਹੋਰ ਜਾਣੋ )
2. ਸੀ ਡੀ ਸਕ੍ਰਿਪਟਾਂ ਨੂੰ ਦਾਖ਼ਲ ਕਰੋ (ਇਹ ਡਾਇਰੈਕਟਰੀ ਨੂੰ ਸਕ੍ਰਿਪਟਾਂ ਵਿੱਚ ਬਦਲਦਾ ਹੈ )
3. Nano examplen.sh ਦਾਖ਼ਲ ਕਰੋ (ਜਿੱਥੇ n ਉਹ ਉਦਾਹਰਣ ਹੈ ਜਿਸਤੇ ਤੁਸੀਂ ਕੰਮ ਕਰ ਰਹੇ ਹੋ)
4. ਸਕਰਿਪਟ ਦਰਜ ਕਰੋ
5. ਬੰਦ ਕਰਨ ਲਈ CTRL + O ਅਤੇ ਬਾਹਰ ਜਾਣ ਲਈ CTRL + X ਦਬਾਓ
6. ਚਲਾਓ bash examplen.sh (ਫੇਰ, n ਜਿਸ ਦੇ ਨਾਲ ਤੁਸੀਂ ਕੰਮ ਕਰ ਰਹੇ ਹੋ)

ਇੱਕ ਸੂਚੀ ਦੇ ਦੁਆਰਾ ਕਿਵੇਂ ਲੂਪ ਕਰਨਾ ਹੈ

#! / bin / bash
ਨੰਬਰ ਲਈ 1 2 3 4 5
ਕਰੋ
ਈਕੋ $ ਨੰਬਰ
ਕੀਤਾ
0 ਤੋਂ ਬਾਹਰ

"ਲਈ" ਲੂਪਸ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦਾ ਬਹਾਲ ਤਰੀਕਾ ਕੁਝ ਹੋਰ ਵੱਖੋ ਵੱਖਰੀ ਪਰੋਗਰਾਮਿੰਗ ਅਤੇ ਸਕ੍ਰਿਪਟਿੰਗ ਭਾਸ਼ਾਵਾਂ ਨੂੰ "ਲਈ" ਲੂਪਸ ਦੇ ਤੌਰ ਤੇ ਵੰਡਦਾ ਹੈ. ਆਉ ਸਕਰਿਪਟ ਨੂੰ ਤੋੜ ਦੇਈਏ ...

ਇੱਕ "BASH" ਲਈ "ਲੂਪ" ਵਿੱਚ, ਜੋ ਕਰਦੇ ਹਨ ਅਤੇ ਕੀਤੇ ਗਏ ਵਿੱਚ ਬਿਆਨ ਇਕ ਵਾਰ ਸੂਚੀ ਵਿੱਚ ਹਰੇਕ ਆਈਟਮ ਲਈ ਕੀਤੇ ਜਾਂਦੇ ਹਨ.

ਉਪਰੋਕਤ ਉਦਾਹਰਨ ਵਿੱਚ, ਸੂਚੀ ਵਿੱਚ ਉਹ ਹਰ ਚੀਜ ਹੈ ਜੋ ਸ਼ਬਦ ਦੇ ਬਾਅਦ ਆਉਂਦੀ ਹੈ (ਭਾਵ 1 2 3 4 5).

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

ਈਕੋ ਸਟੇਟਮੈਂਟ ਸਕ੍ਰੀਨ ਤੇ ਜਾਣਕਾਰੀ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨ ਲਈ ਵਰਤੀ ਜਾਂਦੀ ਹੈ.

ਇਸ ਲਈ, ਇਸ ਉਦਾਹਰਨ ਵਿੱਚ ਨੰਬਰ 1 ਤੋਂ 5 ਲਏ ਜਾਂਦੇ ਹਨ ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਇੱਕ ਤੋਂ ਬਾਅਦ ਇੱਕ ਸਕ੍ਰੀਨ ਤੇ ਆਉਟਪੁੱਟ ਆਉਂਦੇ ਹਨ:

• 1
• 2
• 3
• 4
• 5

ਇੱਕ ਸਟਾਰਟ ਅਤੇ ਐਂਡ ਪੁਆਇੰਟ ਵਿਚਕਾਰ ਲੂਪ ਕਿਵੇਂ ਕਰਨਾ ਹੈ

ਉਪਰੋਕਤ ਉਦਾਹਰਨ ਨਾਲ ਮੁਸ਼ਕਲ ਇਹ ਹੈ ਕਿ ਜੇਕਰ ਤੁਸੀਂ ਇੱਕ ਵੱਡੀ ਸੂਚੀ (1 ਤੋਂ 500) ਤੇ ਕਾਰਵਾਈ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਇਹ ਸਭ ਤੋਂ ਪਹਿਲਾਂ ਸਭ ਅੰਕ ਟਾਈਪ ਕਰਨ ਲਈ ਉਮਰ ਲੈ ਸਕਦਾ ਹੈ.

ਇਹ ਸਾਨੂੰ ਦੂਜੇ ਉਦਾਹਰਨ ਤੇ ਲੈ ਆਇਆ ਹੈ ਜੋ ਦਿਖਾਉਂਦਾ ਹੈ ਕਿ ਕਿਵੇਂ ਸ਼ੁਰੂ ਅਤੇ ਸਮਾਪਤੀ ਬਿੰਦੂ ਨਿਰਧਾਰਤ ਕਰਨਾ ਹੈ:

#! / bin / bash
{1..10} ਵਿਚ ਨੰਬਰ ਲਈ
ਕਰੋ
ਈਕੋ "$ ਨੰਬਰ"
ਕੀਤਾ
0 ਤੋਂ ਬਾਹਰ

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

ਮੁੱਖ ਅੰਤਰ ਉਹ ਤਰੀਕਾ ਹੈ ਜਿਸਦੀ ਸੂਚੀ ਬਣਦੀ ਹੈ. ਕਰਲੀ ਬ੍ਰੈਕਿਟਸ {} ਅਸਲ ਵਿੱਚ ਇੱਕ ਰੇਂਜ ਸੰਕੇਤ ਕਰਦੀ ਹੈ, ਅਤੇ ਇਸ ਸੀਮਾ ਵਿੱਚ, 1 ਤੋਂ 10 ਦੀ ਸੀਮਾ ਹੈ (ਦੋ ਬਿੰਦੀਆਂ ਇੱਕ ਰੇਂਜ ਦੇ ਸ਼ੁਰੂ ਅਤੇ ਅੰਤ ਨੂੰ ਅੱਡ ਕਰਦੇ ਹਨ)

ਇਸ ਉਦਾਹਰਨ, ਇਸ ਲਈ, ਹਰ ਇੱਕ ਨੰਬਰ ਤੋਂ 1 ਅਤੇ 10 ਦੇ ਵਿੱਚਕਾਰ ਚੱਲਦੀ ਹੈ ਅਤੇ ਨੰਬਰ ਨੂੰ ਸਕ੍ਰੀਨ ਤੇ ਦਿਖਾਇਆ ਜਾਂਦਾ ਹੈ:

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10

ਉਸੇ ਹੀ ਲੂਪ ਨੂੰ ਇਸ ਤਰ੍ਹਾਂ ਲਿਖਿਆ ਗਿਆ ਹੈ, ਜਿਸ ਦੀ ਪਹਿਲੀ ਉਦਾਹਰਨ ਹੈ:

ਨੰਬਰ ਲਈ 1 2 3 4 5 6 7 8 9 10

ਰੇਂਜ ਵਿਚ ਨੰਬਰ ਛੱਡਣ ਬਾਰੇ ਕਿਵੇਂ?

ਪਿਛਲੇ ਉਦਾਹਰਣ ਵਿੱਚ ਦਿਖਾਇਆ ਗਿਆ ਹੈ ਕਿ ਸ਼ੁਰੂਆਤ ਅਤੇ ਸਮਾਪਤੀ ਬਿੰਦੂ ਦੇ ਵਿਚਕਾਰ ਕਿਵੇਂ ਲੂਪ ਕਰਨਾ ਹੈ, ਇਸ ਲਈ ਹੁਣ ਅਸੀਂ ਦੇਖਾਂਗੇ ਕਿ ਕਿਵੇਂ ਰੇਂਜ ਵਿੱਚ ਨੰਬਰਾਂ ਨੂੰ ਛੱਡਣਾ ਹੈ.

ਕਲਪਨਾ ਕਰੋ ਕਿ ਤੁਸੀਂ 0 ਅਤੇ 100 ਦੇ ਵਿਚਕਾਰ ਲੂਪ ਚਾਹੁੰਦੇ ਹੋ ਪਰ ਸਿਰਫ ਹਰ ਦਸਵੇਂ ਨੰਬਰ ਨੂੰ ਦਿਖਾਓ. ਹੇਠਲੀ ਸਕ੍ਰਿਪਟ ਦਿਖਾਉਂਦੀ ਹੈ ਕਿ ਇਹ ਕਿਵੇਂ ਕਰਨਾ ਹੈ:

#! / bin / bash
{0. .100..10} ਵਿਚ ਨੰਬਰ ਲਈ
ਕਰੋ
ਈਕੋ "$ ਨੰਬਰ"
ਕੀਤਾ
0 ਤੋਂ ਬਾਹਰ

ਨਿਯਮ ਅਸਲ ਵਿੱਚ ਇੱਕੋ ਜਿਹੇ ਹਨ. ਇੱਕ ਸੂਚੀ, ਇੱਕ ਵੇਰੀਏਬਲ, ਅਤੇ ਕਰਨ ਅਤੇ ਕਰਨ ਦੇ ਵਿਚਕਾਰ ਕੀਤੇ ਜਾਣ ਵਾਲੇ ਸਟੇਟਮੈਂਟਸ ਦਾ ਸੈੱਟ ਹੈ . ਸੂਚੀ ਇਸ ਸਮੇਂ ਇਸ ਤਰ੍ਹਾਂ ਵੇਖਦੀ ਹੈ: {0..100..10}.

ਪਹਿਲੀ ਸੰਖਿਆ 0 ਹੈ ਅਤੇ ਅੰਤਮ ਨੰਬਰ 100 ਹੈ. ਤੀਜੇ ਨੰਬਰ (10) ਸੂਚੀ ਵਿੱਚ ਆਈਟਮਾਂ ਦੀ ਗਿਣਤੀ ਹੈ ਜੋ ਇਹ ਛੱਡ ਦੇਵੇਗਾ.

ਉਪਰੋਕਤ ਉਦਾਹਰਨ, ਇਸ ਲਈ, ਹੇਠਲੀ ਆਊਟਪੁੱਟ ਦਰਸਾਉਂਦੀ ਹੈ:

• 0
• 10
• 20
• 30
• 40
• 50
• 60
• 70
• 80
• 90
• 100

ਲੂਪ ਲਈ ਇੱਕ ਹੋਰ ਪਰੰਪਰਾਗਤ ਲੁਕਿੰਗ

ਲੂਪਾਂ ਲਈ ਲਿਖਣ ਦਾ ਬੇਸ ਤਰੀਕਾ ਦੂਸਰੇ ਪ੍ਰੋਗਰਾਮਾਂ ਦੀ ਭਾਸ਼ਾ ਦੇ ਮੁਕਾਬਲੇ ਥੋੜ੍ਹਾ ਅਜੀਬ ਹੁੰਦਾ ਹੈ.

ਪਰ, ਤੁਸੀਂ ਇਸ ਤਰ੍ਹਾਂ ਕਰ ਸਕਦੇ ਹੋ ਜਿਵੇਂ ਕਿ ਸੀ ਪ੍ਰੋਗ੍ਰਾਮਿੰਗ ਭਾਸ਼ਾ ਨੂੰ ਉਸੇ ਤਰ੍ਹਾਂ ਸਟਾਈਲ ਲਈ ਲੂਪ ਲਿਖ ਸਕਦੇ ਹੋ:

#! / bin / bash
ਲਈ ((ਨੰਬਰ = 1; ਨੰਬਰ <100; ਨੰਬਰ ++))
{
ਜੇ (($ ਨੰਬਰ% 5 == 0))
ਫਿਰ
ਈਕੋ "$ ਨੰਬਰ 5 ਦੁਆਰਾ ਵੰਡਿਆ ਜਾ ਸਕਦਾ ਹੈ"
ਫਾਈ
}
0 ਤੋਂ ਬਾਹਰ

ਵੇਅਰਿਏਬਲ ਨੰਬਰ ਨੂੰ 1 (ਨੰਬਰ = 1 ) ਵਿੱਚ ਲਗਾ ਕੇ ਲੂਪ ਸ਼ੁਰੂ ਹੁੰਦਾ ਹੈ. ਜਦੋਂ ਨੰਬਰ ਦੀ ਕੀਮਤ 100 ਤੋਂ ਘੱਟ ਹੈ ( ਨੰਬਰ <100 ), ਲੂਪ ਇਸਦੀ ਗਤੀ ਰੁਕੇਗੀ. ਹਰੇਕ ਦੁਹਰਾਉਣ ( ਨੰਬਰ ++ ) ਤੋਂ ਬਾਅਦ ਇਸ ਵਿਚ 1 ਜੋੜ ਕੇ ਨੰਬਰ ਦੀ ਵੈਲਯੂ ਬਦਲਦੀ ਹੈ.

ਕਰਲੀ ਬ੍ਰੇਸਿਜ਼ ਦੇ ਵਿਚਲੀ ਹਰ ਚੀਜ ਨੂੰ ਲੂਪ ਦੇ ਹਰ ਆਵਾਜਾਈ ਦੁਆਰਾ ਕੀਤਾ ਜਾਂਦਾ ਹੈ.

ਬ੍ਰੇਸ ਦੇ ਵਿਚਕਾਰ ਬਿੱਟ ਇੱਕ ਨੰਬਰ ਦਾ ਮੁੱਲ ਚੈੱਕ ਕਰਦਾ ਹੈ, ਇਸ ਨੂੰ 5 ਨਾਲ ਵੰਡਦਾ ਹੈ, ਅਤੇ ਬਾਕੀ ਦੇ 0 ਦੀ ਤੁਲਨਾ ਕਰਦਾ ਹੈ. ਜੇਕਰ ਬਾਕੀ 0 ਹੈ ਤਾਂ ਨੰਬਰ 5 ਦੁਆਰਾ ਵੰਡਿਆ ਜਾ ਸਕਦਾ ਹੈ ਅਤੇ ਫਿਰ ਸਕਰੀਨ ਤੇ ਪ੍ਰਦਰਸ਼ਿਤ ਹੁੰਦਾ ਹੈ.

ਉਦਾਹਰਣ ਲਈ:

• 5 ਵਿਭਾਜਿਤ 5 ਹੈ
• 10 ਵਿਭਾਜਿਤ 5 ਹੈ
• 15 5 ਦੁਆਰਾ ਵੰਡਿਆ ਜਾ ਸਕਦਾ ਹੈ

ਜੇ ਤੁਸੀਂ ਦੁਪਹਿਰ ਦੇ ਪੜਾਅ ਦੇ ਆਕਾਰ ਨੂੰ ਬਦਲਣਾ ਚਾਹੁੰਦੇ ਹੋ ਤਾਂ ਤੁਸੀਂ ਨੰਬਰ + ਨੰਬਰ + 2 , ਨੰਬਰ = ਨੰਬਰ + 5 , ਜਾਂ ਨੰਬਰ = ਨੰਬਰ + 10 ਆਦਿ ਦੇ ਨੰਬਰ ++ ਸੈਕਸ਼ਨ ਵਿੱਚ ਸੋਧ ਕਰ ਸਕਦੇ ਹੋ.

ਇਸ ਨੂੰ ਅੱਗੇ + + 2 ਜਾਂ ਅੰਕ + = 5 ਤੇ ਘਟਾ ਦਿੱਤਾ ਜਾ ਸਕਦਾ ਹੈ.

ਇੱਕ ਵਿਹਾਰਕ ਉਦਾਹਰਨ

ਲੂਪਸ ਲਈ ਨੰਬਰ ਦੀ ਰੀਤੀ-ਵਿਵਰਤ ਸੂਚੀ ਤੋਂ ਜਿਆਦਾ ਕੁਝ ਹੋ ਸਕਦਾ ਹੈ. ਤੁਸੀਂ ਅਸਲ ਵਿੱਚ ਦੂਜੀ ਕਮਾਂਡਜ਼ ਦੇ ਆਉਟਪੁੱਟ ਨੂੰ ਸੂਚੀ ਵਿੱਚ ਇਸਤੇਮਾਲ ਕਰ ਸਕਦੇ ਹੋ.

ਹੇਠ ਦਿੱਤੀ ਉਦਾਹਰਨ ਦਿਖਾਉਂਦੀ ਹੈ ਕਿ ਆਡੀਓ ਫਾਇਲਾਂ ਨੂੰ MP3 ਤੋਂ WAV ਵਿੱਚ ਕਿਵੇਂ ਤਬਦੀਲ ਕਰਨਾ ਹੈ:

#! / bin / bash

ਇਸ ਉਦਾਹਰਨ ਵਿੱਚ ਸੂਚੀ ਵਿੱਚ ਮੌਜੂਦਾ ਫਾਈਲ ਵਿੱਚ .MP3 ਐਕਸਟੈਂਸ਼ਨ ਵਾਲੀ ਹਰੇਕ ਫਾਈਲ ਹੈ ਅਤੇ ਵੇਰੀਏਬਲ ਇੱਕ ਫਾਈਲ ਹੈ .

Mpg ਕਮਾਂਡ MPA ਤੋਂ WAV ਵਿੱਚ ਬਦਲ ਜਾਂਦੀ ਹੈ. ਹਾਲਾਂਕਿ, ਤੁਹਾਨੂੰ ਸ਼ਾਇਦ ਪਹਿਲਾਂ ਇਸ ਨੂੰ ਆਪਣੇ ਪੈਕੇਜ ਮੈਨੇਜਰ ਰਾਹੀਂ ਇੰਸਟਾਲ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ.