ਸ਼ੈੱਲ ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਗੇਟਓਪਟਸ ਦੀ ਵਰਤੋਂ ਕਿਵੇਂ ਕਰੀਏ'] ", 'ਸ਼ੈੱਲ ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਗੇਟਓਪਟਸ ਦੀ ਵਰਤੋਂ ਕਿਵੇਂ ਕਰਨੀ ਹੈ', ' [\'ਸ਼ੈੱਲ ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਗੇਟਓਪਟਸ ਦੀ ਵਰਤੋਂ ਕਿਵੇਂ ਕਰਨੀ ਹੈ\', \'ਗੇਟਓਪਟਸ\' ਯੂਨਿਕਸ ਸ਼ੈੱਲ ਸਕ੍ਰਿਪਟਾਂ ਵਿੱਚ ਇੱਕ ਕਮਾਂਡ-ਲਾਈਨ ਵਿਕਲਪ ਪਾਰਸ ਕਰਨ ਦਾ ਟੂਲ ਹੈ। ਇਹ ਤੁਹਾਨੂੰ ਵਿਕਲਪਾਂ ਅਤੇ ਵਿਕਲਪਾਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ।ਤੁਹਾਡੀ ਸਕ੍ਰਿਪਟ ਲਈ ਆਰਗੂਮੈਂਟ, ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਕਮਾਂਡ ਲਾਈਨ ਤੋਂ ਪਾਰਸ ਕਰੋ। ਇੱਥੇ ਇੱਕ ਉਦਾਹਰਣ ਹੈ ਕਿ ਸ਼ੈੱਲ ਵਿੱਚ \'ਗੇਟਓਪਟਸ\' ਦੀ ਵਰਤੋਂ ਕਿਵੇਂ ਕਰਨੀ ਹੈ।ਸਕ੍ਰਿਪਟਃ \'\\n\' \'ਬਸ਼ \\n #!/ਬਿਨ/ਬਸ਼ \\n\' ਜਦੋਂ ਕਿ "a" ਦੀ ਚੋਣ ਕਰਦਾ ਹੈ; \\n ਕੇਸ $ਦੀ ਚੋਣ ਕਰੋ \\n a) \\n ਜੇਕਰ [$#-gt 1]; ਤਾਂ \\n ਗੂੰਜ "ਗਲਤੀਃ ਵਿਕਲਪ ਲਈ ਬਹੁਤ ਸਾਰੀਆਂ ਆਰਗੂਮੈਂਟਾਂ- a "\\n ਨਿਕਾਸ 1\\n ਫਾਈ\\ਨ ਆਪਟ _ ਆਰਗ1 =" $OPTARG "\\n; \\n\\\\?) \\n ਗੂੰਜ" ਗਲਤੀਃ ਗਲਤ ਵਿਕਲਪ-$OPTARG "\\n ਨਿਕਾਸ 1\\n; \\n eSAC\\ndone\\n\\nif [-z" $ਆਪਟ _ ਆਰਗ1 "]; ਫਿਰ \\necho "ਗਲਤੀਃ ਵਿਕਲਪ-a ਲਈ ਇੱਕ ਆਰਗੂਮੈਂਟ ਦੀ ਲੋਡ਼ ਹੁੰਦੀ ਹੈ" \\n ਐਗਜ਼ਿਟ 1\\nfi\\n\\necho "ਆਪਟ _ ਆਰਗ1: $ਆਪਟ _ ਆਰਗ1" \\n "\'\\n ਇਸ ਉਦਾਹਰਣ ਵਿੱਚ,\' ਵਾਇਲ \'ਲੂਪ ਇਸ ਉੱਤੇ ਦੁਹਰਾਉਂਦਾ ਹੈਕਮਾਂਡ ਲਾਈਨ ਉੱਤੇ ਵਿਕਲਪ ਪਾਸ ਕੀਤੇ ਗਏ, \'ਗੇਟਓਪਟਸ\' ਦੁਆਰਾ ਪਾਰਸ ਕੀਤੇ ਗਏ। \'ਜੇਕਰ\' ਸਟੇਟਮੈਂਟ ਇਹ ਜਾਂਚਦੀ ਹੈ ਕਿ ਵਿਕਲਪ ਵਿੱਚ ਕੋਈ ਆਰਗੂਮੈਂਟ ਹੈ ਜਾਂ ਨਹੀਂ, ਅਤੇ ਜੇ ਅਜਿਹਾ ਹੈ, ਤਾਂ ਇਸ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰੋ\'ਓਪਟ _ ਆਰਗ1\' ਵੇਰੀਏਬਲ। \'ਕੇਸ\' ਸਟੇਟਮੈਂਟ ਹਰੇਕ ਵਿਕਲਪ ਅਤੇ ਇਸ ਦੇ ਸੰਭਵ ਆਰਗੂਮੈਂਟ ਨੂੰ ਸੰਭਾਲਦੀ ਹੈ। \'\\\\?\' ਸਮੀਕਰਨ ਦੀ ਵਰਤੋਂ ਗਲਤ ਨੂੰ ਸੰਭਾਲਣ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।ਚੋਣਾਂ। \\n\\n ਇਸ ਸਕ੍ਰਿਪਟ ਨੂੰ ਇਸ ਤਰ੍ਹਾਂ ਚਲਾਇਆ ਜਾ ਸਕਦਾ ਹੈਃ \\n \'\' ਬਸ਼\\ n./script.sh-a ਹੈਲੋ\\n \'\\n ਇਹ\'-a \'ਵਿਕਲਪ ਨੂੰ ਪਾਰਸ ਕਰੇਗਾ ਅਤੇ ਆਰਗੂਮੈਂਟ ਨੂੰ\' ਹੈਲੋ \'ਨਿਰਧਾਰਤ ਕਰੇਗਾ\'ਓਪਟ _ ਆਰਗ1\'. ਜੇਕਰ ਵਿਕਲਪ ਨਿਰਧਾਰਤ ਨਹੀਂ ਕੀਤਾ ਗਿਆ ਹੈ ਜਾਂ ਬਹੁਤ ਸਾਰੀਆਂ ਆਰਗੂਮੈਂਟਾਂ ਹਨ, ਤਾਂ ਇੱਕ ਗਲਤੀ ਸੁਨੇਹਾ ਪ੍ਰਦਰਸ਼ਿਤ ਕੀਤਾ ਜਾਵੇਗਾ। \',\' ਇਸ ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਕੀ ਹੈ \'] ', 'ਸ਼ੈੱਲ ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਗੇਟਓਪਟਸ ਦੀ ਵਰਤੋਂ ਕਿਵੇਂ ਕਰਨੀ ਹੈ', ' [\'ਸ਼ੈੱਲ ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਗੇਟਓਪਟਸ ਦੀ ਵਰਤੋਂ ਕਿਵੇਂ ਕਰਨੀ ਹੈ\', \'ਗੇਟਓਪਟਸ\' ਯੂਨਿਕਸ ਸ਼ੈੱਲ ਸਕ੍ਰਿਪਟਾਂ ਵਿੱਚ ਇੱਕ ਕਮਾਂਡ-ਲਾਈਨ ਵਿਕਲਪ ਪਾਰਸ ਕਰਨ ਦਾ ਟੂਲ ਹੈ। ਇਹ ਤੁਹਾਨੂੰ ਵਿਕਲਪਾਂ ਅਤੇ ਵਿਕਲਪਾਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ।ਤੁਹਾਡੀ ਸਕ੍ਰਿਪਟ ਲਈ ਆਰਗੂਮੈਂਟ, ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਕਮਾਂਡ ਲਾਈਨ ਤੋਂ ਪਾਰਸ ਕਰੋ। ਇੱਥੇ ਇੱਕ ਉਦਾਹਰਣ ਹੈ ਕਿ ਸ਼ੈੱਲ ਵਿੱਚ \'ਗੇਟਓਪਟਸ\' ਦੀ ਵਰਤੋਂ ਕਿਵੇਂ ਕਰਨੀ ਹੈ।ਸਕ੍ਰਿਪਟਃ \'\\n\' \'ਬਸ਼ \\n #!/ਬਿਨ/ਬਸ਼ \\n\' ਜਦੋਂ ਕਿ "a" ਦੀ ਚੋਣ ਕਰਦਾ ਹੈ; \\n ਕੇਸ $ਦੀ ਚੋਣ ਕਰੋ \\n a) \\n ਜੇਕਰ [$#-gt 1]; ਤਾਂ \\n ਗੂੰਜ "ਗਲਤੀਃ ਵਿਕਲਪ ਲਈ ਬਹੁਤ ਸਾਰੀਆਂ ਆਰਗੂਮੈਂਟਾਂ- a "\\n ਨਿਕਾਸ 1\\n ਫਾਈ\\ਨ ਆਪਟ _ ਆਰਗ1 =" $OPTARG "\\n;; \\n\\\\?) \\n ਗੂੰਜ" ਗਲਤੀਃ ਗਲਤ ਵਿਕਲਪ-$OPTARG "\\n ਨਿਕਾਸ 1\\n; \\n eSAC\\ndone\\n\\nif [-z" $ਆਪਟ _ ਆਰਗ1 "]; ਫਿਰ \\necho "ਗਲਤੀਃ ਵਿਕਲਪ-a ਲਈ ਇੱਕ ਆਰਗੂਮੈਂਟ ਦੀ ਲੋਡ਼ ਹੁੰਦੀ ਹੈ" \\n ਐਗਜ਼ਿਟ 1\\nfi\\n\\necho "ਆਪਟ _ ਆਰਗ1: $ਆਪਟ _ ਆਰਗ1" \\n "\'\\n ਇਸ ਉਦਾਹਰਣ ਵਿੱਚ,\' ਵਾਇਲ \'ਲੂਪ ਇਸ ਉੱਤੇ ਦੁਹਰਾਉਂਦਾ ਹੈਕਮਾਂਡ ਲਾਈਨ ਉੱਤੇ ਵਿਕਲਪ ਪਾਸ ਕੀਤੇ ਗਏ, \'ਗੇਟਓਪਟਸ\' ਦੁਆਰਾ ਪਾਰਸ ਕੀਤੇ ਗਏ। \'ਜੇਕਰ\' ਸਟੇਟਮੈਂਟ ਇਹ ਜਾਂਚਦੀ ਹੈ ਕਿ ਵਿਕਲਪ ਵਿੱਚ ਕੋਈ ਆਰਗੂਮੈਂਟ ਹੈ ਜਾਂ ਨਹੀਂ, ਅਤੇ ਜੇ ਅਜਿਹਾ ਹੈ, ਤਾਂ ਇਸ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰੋ\'ਓਪਟ _ ਆਰਗ1\' ਵੇਰੀਏਬਲ। \'ਕੇਸ\' ਸਟੇਟਮੈਂਟ ਹਰੇਕ ਵਿਕਲਪ ਅਤੇ ਇਸ ਦੇ ਸੰਭਵ ਆਰਗੂਮੈਂਟ ਨੂੰ ਸੰਭਾਲਦੀ ਹੈ। \'\\\\?\' ਸਮੀਕਰਨ ਦੀ ਵਰਤੋਂ ਗਲਤ ਨੂੰ ਸੰਭਾਲਣ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।ਚੋਣਾਂ। \\n\\n ਇਸ ਸਕ੍ਰਿਪਟ ਨੂੰ ਇਸ ਤਰ੍ਹਾਂ ਚਲਾਇਆ ਜਾ ਸਕਦਾ ਹੈਃ \\n \'\' ਬਸ਼\\ n./script.sh-a ਹੈਲੋ\\n \'\\n ਇਹ\'-a \'ਵਿਕਲਪ ਨੂੰ ਪਾਰਸ ਕਰੇਗਾ ਅਤੇ ਆਰਗੂਮੈਂਟ ਨੂੰ\' ਹੈਲੋ \'ਨਿਰਧਾਰਤ ਕਰੇਗਾ\'ਓਪਟ _ ਆਰਗ1\'। ਜੇਕਰ ਵਿਕਲਪ ਨਿਰਧਾਰਤ ਨਹੀਂ ਕੀਤਾ ਗਿਆ ਹੈ ਜਾਂ ਬਹੁਤ ਸਾਰੀਆਂ ਆਰਗੂਮੈਂਟਾਂ ਹਨ, ਤਾਂ ਇੱਕ ਗਲਤੀ ਸੁਨੇਹਾ ਪ੍ਰਦਰਸ਼ਿਤ ਕੀਤਾ ਜਾਵੇਗਾ। \',\' ਇਸ ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਕੀ ਹੈ \',\' ਇਸ ਵਿੱਚਸਕ੍ਰਿਪਟ, \'ਕੇਸ\' ਸਟੇਟਮੈਂਟ ਦੀ ਵਰਤੋਂ ਕਮਾਂਡ ਲਾਈਨ ਉੱਤੇ ਪਾਸ ਕੀਤੇ ਗਏ ਹਰੇਕ ਵਿਕਲਪ ਨੂੰ ਇਸ ਦੇ ਸੰਭਵ ਆਰਗੂਮੈਂਟ (ਜ਼) ਦੇ ਨਾਲ ਸੰਭਾਲਣ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। \'ਕੇਸ\' ਸਟੇਟਮੈਂਟ ਇੱਕ ਹੈਸ਼ੈੱਲ ਸਕ੍ਰਿਪਟਿੰਗ ਵਿੱਚ ਕੰਟਰੋਲ-ਫਲੋ ਸਟੇਟਮੈਂਟ ਜੋ ਤੁਹਾਨੂੰ ਇੱਕ ਵੇਰੀਏਬਲ ਦੇ ਮੁੱਲ ਦੇ ਅਧਾਰ ਤੇ ਚਲਾਉਣ ਲਈ ਕਮਾਂਡਾਂ ਦੀ ਇੱਕ ਲਡ਼ੀ ਨਿਰਧਾਰਤ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ ਜਾਂਸਮੀਕਰਨ. \\n\\n ਇਸ ਉਦਾਹਰਣ ਵਿੱਚ, \'ਕੇਸ\' ਸਟੇਟਮੈਂਟ ਦੀ ਵਰਤੋਂ \'ਗੇਟਓਪਟਸ\' ਕਮਾਂਡ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਕਮਾਂਡ ਲਾਈਨ ਉੱਤੇ ਪਾਸ ਕੀਤੇ ਗਏ ਵੱਖ-ਵੱਖ ਵਿਕਲਪਾਂ ਨੂੰ ਸੰਭਾਲਣ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।\'ਕੇਸ\' ਕਥਨ ਵਿੱਚ \'ਜਦੋਂ\' ਧਾਰਾਵਾਂ ਦੀ ਇੱਕ ਲਡ਼ੀ ਹੁੰਦੀ ਹੈ, ਜਿਨ੍ਹਾਂ ਵਿੱਚੋਂ ਹਰੇਕ ਨੂੰ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ ਜੇਕਰ \'OPTARG\' ਵੇਰੀਏਬਲ ਦਾ ਮੁੱਲ ਇਸ ਵਿੱਚ ਦਰਸਾਏ ਗਏ ਪੈਟਰਨ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ।\'ਕੇਸ\' ਸਟੇਟਮੈਂਟ। \\n\\n ਉਦਾਹਰਣ ਵਜੋਂ, ਪਹਿਲਾ \'ਕੇਸ\' ਸਟੇਟਮੈਂਟ ਜਾਂਚਦਾ ਹੈ ਕਿ ਕਮਾਂਡ ਲਾਈਨ ਉੱਤੇ ਪਾਸ ਕੀਤਾ ਵਿਕਲਪ \'-a\' ਹੈ ਜਾਂ ਨਹੀਂ। ਜੇ ਹੈ, ਤਾਂ \'ਜੇਕਰ\'\'ਕੇਸ\' ਸਟੇਟਮੈਂਟ ਦੇ ਅੰਦਰ ਸਟੇਟਮੈਂਟ ਇਹ ਜਾਂਚਦੀ ਹੈ ਕਿ ਕੀ \'-a\' ਵਿਕਲਪ ਲਈ ਕੋਈ ਆਰਗੂਮੈਂਟ ਹੈ। ਜੇ ਹੈ, ਤਾਂ \'ਆਪਟ _ ਆਰਗ1\' ਵੇਰੀਏਬਲ ਨਿਰਧਾਰਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।ਆਰਗੂਮੈਂਟ ਦਾ ਮੁੱਲ। \\n\\n \'ਕੇਸ\' ਸਟੇਟਮੈਂਟ ਸ਼ੈੱਲ ਸਕ੍ਰਿਪਟਿੰਗ ਵਿੱਚ ਬਹੁਤ ਸਾਰੇ ਕੰਟਰੋਲ-ਫਲੋ ਸਟੇਟਮੈਂਟਾਂ ਵਿੱਚੋਂ ਇੱਕ ਹੈ, ਅਤੇ ਇਸ ਨੂੰ ਸੰਯੋਜਨ ਵਿੱਚ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ।ਹੋਰ ਗੁੰਝਲਦਾਰ ਸਕ੍ਰਿਪਟਾਂ ਬਣਾਉਣ ਲਈ ਹੋਰ ਸਟੇਟਮੈਂਟਾਂ ਦੇ ਨਾਲ। \',\' ਮਲਟੀਪਲ ਗੇਟੌਪਟਸ ਬਣਾਓ \'] ', 'ਸ਼ੈੱਲ ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਗੇਟਓਪਟਸ ਦੀ ਵਰਤੋਂ ਕਿਵੇਂ ਕਰਨੀ ਹੈ', ' [\'ਸ਼ੈੱਲ ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਗੇਟਓਪਟਸ ਦੀ ਵਰਤੋਂ ਕਿਵੇਂ ਕਰਨੀ ਹੈ\', \'ਗੇਟਓਪਟਸ\' ਯੂਨਿਕਸ ਸ਼ੈੱਲ ਸਕ੍ਰਿਪਟਾਂ ਵਿੱਚ ਇੱਕ ਕਮਾਂਡ-ਲਾਈਨ ਵਿਕਲਪ ਪਾਰਸ ਕਰਨ ਦਾ ਟੂਲ ਹੈ। ਇਹ ਤੁਹਾਨੂੰ ਵਿਕਲਪਾਂ ਅਤੇ ਵਿਕਲਪਾਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ।ਤੁਹਾਡੀ ਸਕ੍ਰਿਪਟ ਲਈ ਆਰਗੂਮੈਂਟ, ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਕਮਾਂਡ ਲਾਈਨ ਤੋਂ ਪਾਰਸ ਕਰੋ। ਇੱਥੇ ਇੱਕ ਉਦਾਹਰਣ ਹੈ ਕਿ ਸ਼ੈੱਲ ਵਿੱਚ \'ਗੇਟਓਪਟਸ\' ਦੀ ਵਰਤੋਂ ਕਿਵੇਂ ਕਰਨੀ ਹੈ।ਸਕ੍ਰਿਪਟਃ \'\\n\' \'ਬਸ਼ \\n #!/ਬਿਨ/ਬਸ਼ \\n\' ਜਦੋਂ ਕਿ "a" ਦੀ ਚੋਣ ਕਰਦਾ ਹੈ; \\n ਕੇਸ $ਦੀ ਚੋਣ ਕਰੋ \\n a) \\n ਜੇਕਰ [$#-gt 1]; ਤਾਂ \\n ਗੂੰਜ "ਗਲਤੀਃ ਵਿਕਲਪ ਲਈ ਬਹੁਤ ਸਾਰੀਆਂ ਆਰਗੂਮੈਂਟਾਂ- a "\\n ਨਿਕਾਸ 1\\n ਫਾਈ\\ਨ ਆਪਟ _ ਆਰਗ1 =" $OPTARG "\\n;; \\n\\\\?) \\n ਗੂੰਜ" ਗਲਤੀਃ ਗਲਤ ਵਿਕਲਪ-$OPTARG "\\n ਨਿਕਾਸ 1\\n; \\n eSAC\\ndone\\n\\nif [-z" $ਆਪਟ _ ਆਰਗ1 "]; ਫਿਰ \\necho "ਗਲਤੀਃ ਵਿਕਲਪ-a ਲਈ ਇੱਕ ਆਰਗੂਮੈਂਟ ਦੀ ਲੋਡ਼ ਹੁੰਦੀ ਹੈ" \\n ਐਗਜ਼ਿਟ 1\\nfi\\n\\necho "ਆਪਟ _ ਆਰਗ1: $ਆਪਟ _ ਆਰਗ1" \\n "\'\\n ਇਸ ਉਦਾਹਰਣ ਵਿੱਚ,\' ਵਾਇਲ \'ਲੂਪ ਇਸ ਉੱਤੇ ਦੁਹਰਾਉਂਦਾ ਹੈਕਮਾਂਡ ਲਾਈਨ ਉੱਤੇ ਵਿਕਲਪ ਪਾਸ ਕੀਤੇ ਗਏ, \'ਗੇਟਓਪਟਸ\' ਦੁਆਰਾ ਪਾਰਸ ਕੀਤੇ ਗਏ। \'ਜੇਕਰ\' ਸਟੇਟਮੈਂਟ ਇਹ ਜਾਂਚਦੀ ਹੈ ਕਿ ਵਿਕਲਪ ਵਿੱਚ ਕੋਈ ਆਰਗੂਮੈਂਟ ਹੈ ਜਾਂ ਨਹੀਂ, ਅਤੇ ਜੇ ਅਜਿਹਾ ਹੈ, ਤਾਂ ਇਸ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰੋ\'ਓਪਟ _ ਆਰਗ1\' ਵੇਰੀਏਬਲ। \'ਕੇਸ\' ਸਟੇਟਮੈਂਟ ਹਰੇਕ ਵਿਕਲਪ ਅਤੇ ਇਸ ਦੇ ਸੰਭਵ ਆਰਗੂਮੈਂਟ ਨੂੰ ਸੰਭਾਲਦੀ ਹੈ। \'\\\\?\' ਸਮੀਕਰਨ ਦੀ ਵਰਤੋਂ ਗਲਤ ਨੂੰ ਸੰਭਾਲਣ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।ਚੋਣਾਂ। \\n\\n ਇਸ ਸਕ੍ਰਿਪਟ ਨੂੰ ਇਸ ਤਰ੍ਹਾਂ ਚਲਾਇਆ ਜਾ ਸਕਦਾ ਹੈਃ \\n \'\' ਬਸ਼\\ n./script.sh-a ਹੈਲੋ\\n \'\\n ਇਹ\'-a \'ਵਿਕਲਪ ਨੂੰ ਪਾਰਸ ਕਰੇਗਾ ਅਤੇ ਆਰਗੂਮੈਂਟ ਨੂੰ\' ਹੈਲੋ \'ਨਿਰਧਾਰਤ ਕਰੇਗਾ\'ਓਪਟ _ ਆਰਗ1\'। ਜੇਕਰ ਵਿਕਲਪ ਨਿਰਧਾਰਤ ਨਹੀਂ ਕੀਤਾ ਗਿਆ ਹੈ ਜਾਂ ਬਹੁਤ ਸਾਰੀਆਂ ਆਰਗੂਮੈਂਟਾਂ ਹਨ, ਤਾਂ ਇੱਕ ਗਲਤੀ ਸੁਨੇਹਾ ਪ੍ਰਦਰਸ਼ਿਤ ਕੀਤਾ ਜਾਵੇਗਾ। \',\' ਇਸ ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਕੀ ਹੈ \',\' ਇਸ ਵਿੱਚਸਕ੍ਰਿਪਟ, \'ਕੇਸ\' ਸਟੇਟਮੈਂਟ ਦੀ ਵਰਤੋਂ ਕਮਾਂਡ ਲਾਈਨ ਉੱਤੇ ਪਾਸ ਕੀਤੇ ਗਏ ਹਰੇਕ ਵਿਕਲਪ ਨੂੰ ਇਸ ਦੇ ਸੰਭਵ ਆਰਗੂਮੈਂਟ (ਜ਼) ਦੇ ਨਾਲ ਸੰਭਾਲਣ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। \'ਕੇਸ\' ਸਟੇਟਮੈਂਟ ਇੱਕ ਹੈਸ਼ੈੱਲ ਸਕ੍ਰਿਪਟਿੰਗ ਵਿੱਚ ਕੰਟਰੋਲ-ਫਲੋ ਸਟੇਟਮੈਂਟ ਜੋ ਤੁਹਾਨੂੰ ਇੱਕ ਵੇਰੀਏਬਲ ਦੇ ਮੁੱਲ ਦੇ ਅਧਾਰ ਤੇ ਚਲਾਉਣ ਲਈ ਕਮਾਂਡਾਂ ਦੀ ਇੱਕ ਲਡ਼ੀ ਨਿਰਧਾਰਤ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ ਜਾਂਸਮੀਕਰਨ. \\n\\n ਇਸ ਉਦਾਹਰਣ ਵਿੱਚ, \'ਕੇਸ\' ਸਟੇਟਮੈਂਟ ਦੀ ਵਰਤੋਂ \'ਗੇਟਓਪਟਸ\' ਕਮਾਂਡ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਕਮਾਂਡ ਲਾਈਨ ਉੱਤੇ ਪਾਸ ਕੀਤੇ ਗਏ ਵੱਖ-ਵੱਖ ਵਿਕਲਪਾਂ ਨੂੰ ਸੰਭਾਲਣ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।\'ਕੇਸ\' ਕਥਨ ਵਿੱਚ \'ਜਦੋਂ\' ਧਾਰਾਵਾਂ ਦੀ ਇੱਕ ਲਡ਼ੀ ਹੁੰਦੀ ਹੈ, ਜਿਨ੍ਹਾਂ ਵਿੱਚੋਂ ਹਰੇਕ ਨੂੰ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ ਜੇਕਰ \'OPTARG\' ਵੇਰੀਏਬਲ ਦਾ ਮੁੱਲ ਇਸ ਵਿੱਚ ਦਰਸਾਏ ਗਏ ਪੈਟਰਨ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ।\'ਕੇਸ\' ਸਟੇਟਮੈਂਟ। \\n\\n ਉਦਾਹਰਣ ਵਜੋਂ, ਪਹਿਲਾ \'ਕੇਸ\' ਸਟੇਟਮੈਂਟ ਜਾਂਚਦਾ ਹੈ ਕਿ ਕਮਾਂਡ ਲਾਈਨ ਉੱਤੇ ਪਾਸ ਕੀਤਾ ਵਿਕਲਪ \'-a\' ਹੈ ਜਾਂ ਨਹੀਂ। ਜੇ ਹੈ, ਤਾਂ \'ਜੇਕਰ\'\'ਕੇਸ\' ਸਟੇਟਮੈਂਟ ਦੇ ਅੰਦਰ ਸਟੇਟਮੈਂਟ ਇਹ ਜਾਂਚਦੀ ਹੈ ਕਿ ਕੀ \'-a\' ਵਿਕਲਪ ਲਈ ਕੋਈ ਆਰਗੂਮੈਂਟ ਹੈ। ਜੇ ਹੈ, ਤਾਂ \'ਆਪਟ _ ਆਰਗ1\' ਵੇਰੀਏਬਲ ਨਿਰਧਾਰਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।ਆਰਗੂਮੈਂਟ ਦਾ ਮੁੱਲ। \\n\\n \'ਕੇਸ\' ਸਟੇਟਮੈਂਟ ਸ਼ੈੱਲ ਸਕ੍ਰਿਪਟਿੰਗ ਵਿੱਚ ਬਹੁਤ ਸਾਰੇ ਕੰਟਰੋਲ-ਫਲੋ ਸਟੇਟਮੈਂਟਾਂ ਵਿੱਚੋਂ ਇੱਕ ਹੈ, ਅਤੇ ਇਸ ਨੂੰ ਸੰਯੋਜਨ ਵਿੱਚ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ।ਵਧੇਰੇ ਗੁੰਝਲਦਾਰ ਸਕ੍ਰਿਪਟਾਂ ਬਣਾਉਣ ਲਈ ਹੋਰ ਸਟੇਟਮੈਂਟਾਂ ਦੇ ਨਾਲ. \',\' ਮਲਟੀਪਲ ਗੇਟਓਪਟਸ ਬਣਾਓ \',\' ਤੁਸੀਂ ਇੱਕ ਸਿੰਗਲ ਸ਼ੈੱਲ ਵਿੱਚ ਮਲਟੀਪਲ \'ਗੇਟਓਪਟਸ\' ਵਿਕਲਪ ਬਣਾ ਸਕਦੇ ਹੋ।\'ਵਾਇਲ\' ਲੂਪ ਵਿੱਚ ਕਈ ਵਿਕਲਪਾਂ ਨੂੰ ਦਰਸਾ ਕੇ ਸਕ੍ਰਿਪਟ ਕਰੋ। ਉਦਾਹਰਨ ਲਈਃ \\n \'\' ਬੈਸ਼\\n #!/ਬਿਨ/ਬੈਸ਼\\n \'ਜਦੋਂ ਕਿ "a b" ਦੀ ਚੋਣ ਕਰਦਾ ਹੈ; \\n ਕੇਸ $ਦੀ ਚੋਣ ਕਰੋ \\n a) \\nਆਪਟ _ ਆਰ. ਜੀ. 1 = "$ਓ. ਪੀ. ਟੀ. ਏ. ਆਰ. ਜੀ". \\n; \\n b) \\n ਆਪਟ _ ਆਰ. ਜੀ. 2 = "$ਓ. ਪੀ. ਟੀ. ਏ. ਆਰ. ਜੀ". \\n; \\n\\\\?ਇਸ ਉਦਾਹਰਣ ਵਿੱਚ, \'ਵਾਇਲ\' ਲੂਪ ਦੋ ਵਿਕਲਪਾਂ \'ਤੇ ਦੁਹਰਾਉਂਦਾ ਹੈਃ\'-a \'ਅਤੇ\'-b \'.\' ਕੇਸ \'ਸਟੇਟਮੈਂਟ ਹੈਂਡਲ ਕਰਦੇ ਹਨਹਰੇਕ ਵਿਕਲਪ ਅਤੇ ਇਸ ਦੀ ਸੰਭਵ ਦਲੀਲ, ਜਿਵੇਂ ਕਿ ਪਿਛਲੀ ਉਦਾਹਰਣ ਵਿੱਚ। \\n\\n ਇਸ ਸਕ੍ਰਿਪਟ ਨੂੰ ਚਲਾਉਣ ਲਈ, ਤੁਸੀਂ ਹੇਠ ਲਿਖਿਆਂ ਦੀ ਵਰਤੋਂ ਕਰੋਗੇਃਕਮਾਂਡਃ \'\\n\' \'bash\\ n./script.sh-a ਹੈਲੋ-b ਸੰਸਾਰ \\n\' \'\\n ਇਹ\' ਹੈਲੋ \'ਅਤੇ\' ਸੰਸਾਰ \'ਦੇ ਮੁੱਲ ਕ੍ਰਮਵਾਰ\' ਆਪਟ _ ਆਰਗ1 \'ਅਤੇ\' ਆਪਟ _ ਆਰਗ2 \'ਨੂੰ ਨਿਰਧਾਰਤ ਕਰੇਗਾ। ਜੇਕਰਕੋਈ ਵੀ ਗਲਤ ਵਿਕਲਪ ਨਿਰਧਾਰਤ ਕੀਤਾ ਗਿਆ ਹੈ, ਇੱਕ ਗਲਤੀ ਸੁਨੇਹਾ ਪ੍ਰਦਰਸ਼ਿਤ ਕੀਤਾ ਜਾਵੇਗਾ। \',\' ਜਾਂਚ ਕਰੋ ਕਿ ਜੇ ਗਲਤੀ ਨਹੀਂ ਦਿਖਾਈ ਦਿੰਦੀ ਤਾਂ ਗੇਟਓਪਟ ਦਿੱਤੇ ਗਏ ਹਨ \'] ', 'ਸ਼ੈੱਲ ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਗੇਟਓਪਟਸ ਦੀ ਵਰਤੋਂ ਕਿਵੇਂ ਕਰਨੀ ਹੈ', ' [\'ਸ਼ੈੱਲ ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਗੇਟਓਪਟਸ ਦੀ ਵਰਤੋਂ ਕਿਵੇਂ ਕਰਨੀ ਹੈ\', \'ਗੇਟਓਪਟਸ\' ਯੂਨਿਕਸ ਸ਼ੈੱਲ ਸਕ੍ਰਿਪਟਾਂ ਵਿੱਚ ਇੱਕ ਕਮਾਂਡ-ਲਾਈਨ ਵਿਕਲਪ ਪਾਰਸ ਕਰਨ ਦਾ ਟੂਲ ਹੈ। ਇਹ ਤੁਹਾਨੂੰ ਵਿਕਲਪਾਂ ਅਤੇ ਵਿਕਲਪਾਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ।ਤੁਹਾਡੀ ਸਕ੍ਰਿਪਟ ਲਈ ਆਰਗੂਮੈਂਟ, ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਕਮਾਂਡ ਲਾਈਨ ਤੋਂ ਪਾਰਸ ਕਰੋ। ਇੱਥੇ ਇੱਕ ਉਦਾਹਰਣ ਹੈ ਕਿ ਸ਼ੈੱਲ ਵਿੱਚ \'ਗੇਟਓਪਟਸ\' ਦੀ ਵਰਤੋਂ ਕਿਵੇਂ ਕਰਨੀ ਹੈ।ਸਕ੍ਰਿਪਟਃ \'\\n\' \'ਬਸ਼ \\n #!/ਬਿਨ/ਬਸ਼ \\n\' ਜਦੋਂ ਕਿ "a" ਦੀ ਚੋਣ ਕਰਦਾ ਹੈ; \\n ਕੇਸ $ਦੀ ਚੋਣ ਕਰੋ \\n a) \\n ਜੇਕਰ [$#-gt 1]; ਤਾਂ \\n ਗੂੰਜ "ਗਲਤੀਃ ਵਿਕਲਪ ਲਈ ਬਹੁਤ ਸਾਰੀਆਂ ਆਰਗੂਮੈਂਟਾਂ- a "\\n ਨਿਕਾਸ 1\\n ਫਾਈ\\ਨ ਆਪਟ _ ਆਰਗ1 =" $OPTARG "\\n;; \\n\\\\?) \\n ਗੂੰਜ" ਗਲਤੀਃ ਗਲਤ ਵਿਕਲਪ-$OPTARG "\\n ਨਿਕਾਸ 1\\n; \\n eSAC\\ndone\\n\\nif [-z" $ਆਪਟ _ ਆਰਗ1 "]; ਫਿਰ \\necho "ਗਲਤੀਃ ਵਿਕਲਪ-a ਲਈ ਇੱਕ ਆਰਗੂਮੈਂਟ ਦੀ ਲੋਡ਼ ਹੁੰਦੀ ਹੈ" \\n ਐਗਜ਼ਿਟ 1\\nfi\\n\\necho "ਆਪਟ _ ਆਰਗ1: $ਆਪਟ _ ਆਰਗ1" \\n "\'\\n ਇਸ ਉਦਾਹਰਣ ਵਿੱਚ,\' ਵਾਇਲ \'ਲੂਪ ਇਸ ਉੱਤੇ ਦੁਹਰਾਉਂਦਾ ਹੈਕਮਾਂਡ ਲਾਈਨ ਉੱਤੇ ਵਿਕਲਪ ਪਾਸ ਕੀਤੇ ਗਏ, \'ਗੇਟਓਪਟਸ\' ਦੁਆਰਾ ਪਾਰਸ ਕੀਤੇ ਗਏ। \'ਜੇਕਰ\' ਸਟੇਟਮੈਂਟ ਇਹ ਜਾਂਚਦੀ ਹੈ ਕਿ ਵਿਕਲਪ ਵਿੱਚ ਕੋਈ ਆਰਗੂਮੈਂਟ ਹੈ ਜਾਂ ਨਹੀਂ, ਅਤੇ ਜੇ ਅਜਿਹਾ ਹੈ, ਤਾਂ ਇਸ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰੋ\'ਓਪਟ _ ਆਰਗ1\' ਵੇਰੀਏਬਲ। \'ਕੇਸ\' ਸਟੇਟਮੈਂਟ ਹਰੇਕ ਵਿਕਲਪ ਅਤੇ ਇਸ ਦੇ ਸੰਭਵ ਆਰਗੂਮੈਂਟ ਨੂੰ ਸੰਭਾਲਦੀ ਹੈ। \'\\\\?\' ਸਮੀਕਰਨ ਦੀ ਵਰਤੋਂ ਗਲਤ ਨੂੰ ਸੰਭਾਲਣ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।ਚੋਣਾਂ। \\n\\n ਇਸ ਸਕ੍ਰਿਪਟ ਨੂੰ ਇਸ ਤਰ੍ਹਾਂ ਚਲਾਇਆ ਜਾ ਸਕਦਾ ਹੈਃ \\n \'\' ਬਸ਼\\ n./script.sh-a ਹੈਲੋ\\n \'\\n ਇਹ\'-a \'ਵਿਕਲਪ ਨੂੰ ਪਾਰਸ ਕਰੇਗਾ ਅਤੇ ਆਰਗੂਮੈਂਟ ਨੂੰ\' ਹੈਲੋ \'ਨਿਰਧਾਰਤ ਕਰੇਗਾ\'ਓਪਟ _ ਆਰਗ1\'। ਜੇਕਰ ਵਿਕਲਪ ਨਿਰਧਾਰਤ ਨਹੀਂ ਕੀਤਾ ਗਿਆ ਹੈ ਜਾਂ ਬਹੁਤ ਸਾਰੀਆਂ ਆਰਗੂਮੈਂਟਾਂ ਹਨ, ਤਾਂ ਇੱਕ ਗਲਤੀ ਸੁਨੇਹਾ ਪ੍ਰਦਰਸ਼ਿਤ ਕੀਤਾ ਜਾਵੇਗਾ। \',\' ਇਸ ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਕੀ ਹੈ \',\' ਇਸ ਵਿੱਚਸਕ੍ਰਿਪਟ, \'ਕੇਸ\' ਸਟੇਟਮੈਂਟ ਦੀ ਵਰਤੋਂ ਕਮਾਂਡ ਲਾਈਨ ਉੱਤੇ ਪਾਸ ਕੀਤੇ ਗਏ ਹਰੇਕ ਵਿਕਲਪ ਨੂੰ ਇਸ ਦੇ ਸੰਭਵ ਆਰਗੂਮੈਂਟ (ਜ਼) ਦੇ ਨਾਲ ਸੰਭਾਲਣ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। \'ਕੇਸ\' ਸਟੇਟਮੈਂਟ ਇੱਕ ਹੈਸ਼ੈੱਲ ਸਕ੍ਰਿਪਟਿੰਗ ਵਿੱਚ ਕੰਟਰੋਲ-ਫਲੋ ਸਟੇਟਮੈਂਟ ਜੋ ਤੁਹਾਨੂੰ ਇੱਕ ਵੇਰੀਏਬਲ ਦੇ ਮੁੱਲ ਦੇ ਅਧਾਰ ਤੇ ਚਲਾਉਣ ਲਈ ਕਮਾਂਡਾਂ ਦੀ ਇੱਕ ਲਡ਼ੀ ਨਿਰਧਾਰਤ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ ਜਾਂਸਮੀਕਰਨ. \\n\\n ਇਸ ਉਦਾਹਰਣ ਵਿੱਚ, \'ਕੇਸ\' ਸਟੇਟਮੈਂਟ ਦੀ ਵਰਤੋਂ \'ਗੇਟਓਪਟਸ\' ਕਮਾਂਡ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਕਮਾਂਡ ਲਾਈਨ ਉੱਤੇ ਪਾਸ ਕੀਤੇ ਗਏ ਵੱਖ-ਵੱਖ ਵਿਕਲਪਾਂ ਨੂੰ ਸੰਭਾਲਣ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।\'ਕੇਸ\' ਕਥਨ ਵਿੱਚ \'ਜਦੋਂ\' ਧਾਰਾਵਾਂ ਦੀ ਇੱਕ ਲਡ਼ੀ ਹੁੰਦੀ ਹੈ, ਜਿਨ੍ਹਾਂ ਵਿੱਚੋਂ ਹਰੇਕ ਨੂੰ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ ਜੇਕਰ \'OPTARG\' ਵੇਰੀਏਬਲ ਦਾ ਮੁੱਲ ਇਸ ਵਿੱਚ ਦਰਸਾਏ ਗਏ ਪੈਟਰਨ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ।\'ਕੇਸ\' ਸਟੇਟਮੈਂਟ। \\n\\n ਉਦਾਹਰਣ ਵਜੋਂ, ਪਹਿਲਾ \'ਕੇਸ\' ਸਟੇਟਮੈਂਟ ਜਾਂਚਦਾ ਹੈ ਕਿ ਕਮਾਂਡ ਲਾਈਨ ਉੱਤੇ ਪਾਸ ਕੀਤਾ ਵਿਕਲਪ \'-a\' ਹੈ ਜਾਂ ਨਹੀਂ। ਜੇ ਹੈ, ਤਾਂ \'ਜੇਕਰ\'\'ਕੇਸ\' ਸਟੇਟਮੈਂਟ ਦੇ ਅੰਦਰ ਸਟੇਟਮੈਂਟ ਇਹ ਜਾਂਚਦੀ ਹੈ ਕਿ ਕੀ \'-a\' ਵਿਕਲਪ ਲਈ ਕੋਈ ਆਰਗੂਮੈਂਟ ਹੈ। ਜੇ ਹੈ, ਤਾਂ \'ਆਪਟ _ ਆਰਗ1\' ਵੇਰੀਏਬਲ ਨਿਰਧਾਰਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।ਆਰਗੂਮੈਂਟ ਦਾ ਮੁੱਲ। \\n\\n \'ਕੇਸ\' ਸਟੇਟਮੈਂਟ ਸ਼ੈੱਲ ਸਕ੍ਰਿਪਟਿੰਗ ਵਿੱਚ ਬਹੁਤ ਸਾਰੇ ਕੰਟਰੋਲ-ਫਲੋ ਸਟੇਟਮੈਂਟਾਂ ਵਿੱਚੋਂ ਇੱਕ ਹੈ, ਅਤੇ ਇਸ ਨੂੰ ਸੰਯੋਜਨ ਵਿੱਚ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ।ਵਧੇਰੇ ਗੁੰਝਲਦਾਰ ਸਕ੍ਰਿਪਟਾਂ ਬਣਾਉਣ ਲਈ ਹੋਰ ਸਟੇਟਮੈਂਟਾਂ ਦੇ ਨਾਲ. \',\' ਮਲਟੀਪਲ ਗੇਟਓਪਟਸ ਬਣਾਓ \',\' ਤੁਸੀਂ ਇੱਕ ਸਿੰਗਲ ਸ਼ੈੱਲ ਵਿੱਚ ਮਲਟੀਪਲ \'ਗੇਟਓਪਟਸ\' ਵਿਕਲਪ ਬਣਾ ਸਕਦੇ ਹੋ।\'ਵਾਇਲ\' ਲੂਪ ਵਿੱਚ ਕਈ ਵਿਕਲਪਾਂ ਨੂੰ ਦਰਸਾ ਕੇ ਸਕ੍ਰਿਪਟ ਕਰੋ। ਉਦਾਹਰਨ ਲਈਃ \\n \'\' ਬੈਸ਼\\n #!/ਬਿਨ/ਬੈਸ਼\\n \'ਜਦੋਂ ਕਿ "a b" ਦੀ ਚੋਣ ਕਰਦਾ ਹੈ; \\n ਕੇਸ $ਦੀ ਚੋਣ ਕਰੋ \\n a) \\nਆਪਟ _ ਆਰ. ਜੀ. 1 = "$ਓ. ਪੀ. ਟੀ. ਏ. ਆਰ. ਜੀ". \\n; \\n b) \\n ਆਪਟ _ ਆਰ. ਜੀ. 2 = "$ਓ. ਪੀ. ਟੀ. ਏ. ਆਰ. ਜੀ". \\n; \\n\\\\?ਇਸ ਉਦਾਹਰਣ ਵਿੱਚ, \'ਵਾਇਲ\' ਲੂਪ ਦੋ ਵਿਕਲਪਾਂ \'ਤੇ ਦੁਹਰਾਉਂਦਾ ਹੈਃ\'-a \'ਅਤੇ\'-b \'.\' ਕੇਸ \'ਸਟੇਟਮੈਂਟ ਹੈਂਡਲ ਕਰਦੇ ਹਨਹਰੇਕ ਵਿਕਲਪ ਅਤੇ ਇਸ ਦੀ ਸੰਭਵ ਦਲੀਲ, ਜਿਵੇਂ ਕਿ ਪਿਛਲੀ ਉਦਾਹਰਣ ਵਿੱਚ। \\n\\n ਇਸ ਸਕ੍ਰਿਪਟ ਨੂੰ ਚਲਾਉਣ ਲਈ, ਤੁਸੀਂ ਹੇਠ ਲਿਖਿਆਂ ਦੀ ਵਰਤੋਂ ਕਰੋਗੇਃਕਮਾਂਡਃ \'\\n\' \'bash\\ n./script.sh-a ਹੈਲੋ-b ਸੰਸਾਰ \\n\' \'\\n ਇਹ\' ਹੈਲੋ \'ਅਤੇ\' ਸੰਸਾਰ \'ਦੇ ਮੁੱਲ ਕ੍ਰਮਵਾਰ\' ਆਪਟ _ ਆਰਗ1 \'ਅਤੇ\' ਆਪਟ _ ਆਰਗ2 \'ਨੂੰ ਨਿਰਧਾਰਤ ਕਰੇਗਾ। ਜੇਕਰਕੋਈ ਵੀ ਗਲਤ ਵਿਕਲਪ ਨਿਰਧਾਰਤ ਕੀਤਾ ਗਿਆ ਹੈ, ਇੱਕ ਗਲਤੀ ਸੁਨੇਹਾ ਪ੍ਰਦਰਸ਼ਿਤ ਕੀਤਾ ਜਾਵੇਗਾ। \',\' ਜਾਂਚ ਕਰੋ ਕਿ ਕੀ ਗੇਟਓਪਟਸ ਦਿੱਤੇ ਗਏ ਹਨ ਜੇ ਗਲਤੀ ਨਹੀਂ ਦਿਖਾਈ ਦਿੰਦੀ \',\' ਜਾਂਚ ਕਰਨ ਲਈ ਕਿ ਕੀ \'ਗੇਟਓਪਟਸ\'ਵਿਕਲਪ ਦਿੱਤੇ ਗਏ ਹਨ, ਤੁਸੀਂ ਇਹ ਜਾਂਚ ਕਰਨ ਲਈ ਇੱਕ ਸਧਾਰਨ \'ਜੇਕਰ\' ਸਟੇਟਮੈਂਟ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ ਕਿ ਕੀ \'ਓ. ਪੀ. ਟੀ. ਆਈ. ਐੱਨ. ਡੀ.\' ਵੇਰੀਏਬਲ ਜ਼ੀਰੋ ਤੋਂ ਵੱਡਾ ਹੈ।ਉਦਾਹਰਨਃ \\n "\'ਬੈਸ਼\\n #!/ਬਿਨ/ਬੈਸ਼\\n\\nif [$#-gt0]; ਫਿਰ \\n ਜਦੋਂ ਕਿ" a b "ਦੀ ਚੋਣ ਕਰਦਾ ਹੈ; \\n ਕੇਸ $ਦੀ ਚੋਣ ਕਰੋ \\n a) \\n ਆਪਟ _ ਆਰਗ1 =" $OPTARG "\\n; \\n b) \\nਆਪਟ _ ਆਰਜੀ2 = "$ਓਪੀਟੀਏਆਰਜੀ" \\n; \\n\\\\?) \\n ਇਕੋ ਗਲਤੀਃ ਗਲਤ ਵਿਕਲਪ-$ਓਪੀਟੀਏਆਰਜੀ "\\n ਐਗਜ਼ਿਟ 1\\n; \\n ਈਐੱਸਏਸੀ\\ਨ ਕੀਤਾ ਗਿਆ \\n\\n ਜੇਕਰ [-z" $ਆਪਟ _ ਆਰਜੀ1 "]।। [-z" $ਆਪਟ _ ਆਰਜੀ2 "];ਫਿਰ \\n echo "ਗਲਤੀਃ ਦੋਵੇਂ ਵਿਕਲਪ-a ਅਤੇ-b ਦੀ ਜ਼ਰੂਰਤ ਹੈ" \\n ਐਗਜ਼ਿਟ 1\\n ਫਾਈ\\ਨ\\ਨ ਈਕੋ "ਆਪਟ _ ਆਰਗ1: $ਆਪਟ _ ਆਰਗ1" \\ਨ ਈਕੋ "ਆਪਟ _ ਆਰਗ2: $ਆਪਟ _ ਆਰਗ2" \\ਨਫੀ\\ਨ "\\ਨ ਇਸ ਵਿੱਚਸਕ੍ਰਿਪਟ, \'ਜੇਕਰ\' ਸਟੇਟਮੈਂਟ ਜਾਂਚਦਾ ਹੈ ਕਿ ਕੀ ਕਮਾਂਡ ਲਾਈਨ ਉੱਤੇ ਕੋਈ ਵਿਕਲਪ ਦਿੱਤੇ ਗਏ ਹਨ। ਜੇਕਰ \'ਓ. ਪੀ. ਟੀ. ਆਈ. ਐੱਨ. ਡੀ.\' ਵੇਰੀਏਬਲ (ਜੋ \'ਗੇਟਓਪਟਸ\' ਦੁਆਰਾ ਸੈੱਟ ਕੀਤਾ ਗਿਆ ਹੈ) ਹੈਜ਼ੀਰੋ ਤੋਂ ਵੱਡਾ, ਫਿਰ ਵਿਕਲਪਾਂ ਨੂੰ ਸੰਭਾਲਣ ਲਈ \'ਵਾਇਲ\' ਲੂਪ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ। ਜੇਕਰ ਕੋਈ ਵਿਕਲਪ ਨਹੀਂ ਦਿੱਤਾ ਜਾਂਦਾ, ਤਾਂ ਇੱਕ ਗਲਤੀ ਸੁਨੇਹਾ ਪ੍ਰਦਰਸ਼ਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। \\n\\n ਨੋਟ ਕਰੋ ਕਿ\'ਜੇਕਰ\' ਬਿਆਨ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਜ਼ਰੂਰੀ ਹੈ ਕਿ \'ਵਾਇਲ\' ਲੂਪ ਸਿਰਫ ਤਾਂ ਹੀ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ ਜੇ ਵਿਕਲਪ ਪ੍ਰਦਾਨ ਕੀਤੇ ਗਏ ਹਨ। ਜੇ \'ਜੇਕਰ\' ਬਿਆਨ ਨੂੰ ਛੱਡ ਦਿੱਤਾ ਗਿਆ ਸੀ,\'ਵਾਇਲ\' ਲੂਪ ਅਜੇ ਵੀ ਚੱਲੇਗਾ ਭਾਵੇਂ ਕੋਈ ਵਿਕਲਪ ਨਿਰਧਾਰਤ ਨਹੀਂ ਕੀਤੇ ਗਏ ਸਨ, ਜੋ ਅਚਾਨਕ ਵਿਵਹਾਰ ਵੱਲ ਲੈ ਜਾ ਸਕਦੇ ਹਨ। \',\' ਕਈ ਵਿਕਲਪ ਬਣਾਉਂਦੇ ਹਨ ਜੋ ਲੈਂਦੇ ਹਨਕਈ ਆਰਗੂਮੈਂਟ ਅਤੇ ਗਲਤੀ ਦਿਖਾਉਂਦਾ ਹੈ ਜੇਕਰ ਕੋਈ ਵਿਕਲਪ ਜਾਂ ਆਰਗੂਮੈਂਟ ਨਹੀਂ ਦਿੱਤੇ ਗਏ ਹਨ \'] ', 'ਸ਼ੈੱਲ ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਗੇਟਓਪਟਸ ਦੀ ਵਰਤੋਂ ਕਿਵੇਂ ਕਰਨੀ ਹੈ', ' [\'ਸ਼ੈੱਲ ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਗੇਟਓਪਟਸ ਦੀ ਵਰਤੋਂ ਕਿਵੇਂ ਕਰਨੀ ਹੈ\', \'ਗੇਟਓਪਟਸ\' ਯੂਨਿਕਸ ਸ਼ੈੱਲ ਸਕ੍ਰਿਪਟਾਂ ਵਿੱਚ ਇੱਕ ਕਮਾਂਡ-ਲਾਈਨ ਵਿਕਲਪ ਪਾਰਸ ਕਰਨ ਦਾ ਟੂਲ ਹੈ। ਇਹ ਤੁਹਾਨੂੰ ਵਿਕਲਪਾਂ ਅਤੇ ਵਿਕਲਪਾਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ।ਤੁਹਾਡੀ ਸਕ੍ਰਿਪਟ ਲਈ ਆਰਗੂਮੈਂਟ, ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਕਮਾਂਡ ਲਾਈਨ ਤੋਂ ਪਾਰਸ ਕਰੋ। ਇੱਥੇ ਇੱਕ ਉਦਾਹਰਣ ਹੈ ਕਿ ਸ਼ੈੱਲ ਵਿੱਚ \'ਗੇਟਓਪਟਸ\' ਦੀ ਵਰਤੋਂ ਕਿਵੇਂ ਕਰਨੀ ਹੈ।ਸਕ੍ਰਿਪਟਃ \'\\n\' \'ਬਸ਼ \\n #!/ਬਿਨ/ਬਸ਼ \\n\' ਜਦੋਂ ਕਿ "a" ਦੀ ਚੋਣ ਕਰਦਾ ਹੈ; \\n ਕੇਸ $ਦੀ ਚੋਣ ਕਰੋ \\n a) \\n ਜੇਕਰ [$#-gt 1]; ਤਾਂ \\n ਗੂੰਜ "ਗਲਤੀਃ ਵਿਕਲਪ ਲਈ ਬਹੁਤ ਸਾਰੀਆਂ ਆਰਗੂਮੈਂਟਾਂ- a "\\n ਨਿਕਾਸ 1\\n ਫਾਈ\\ਨ ਆਪਟ _ ਆਰਗ1 =" $OPTARG "\\n;; \\n\\\\?) \\n ਗੂੰਜ" ਗਲਤੀਃ ਗਲਤ ਵਿਕਲਪ-$OPTARG "\\n ਨਿਕਾਸ 1\\n; \\n eSAC\\ndone\\n\\nif [-z" $ਆਪਟ _ ਆਰਗ1 "]; ਫਿਰ \\necho "ਗਲਤੀਃ ਵਿਕਲਪ-a ਲਈ ਇੱਕ ਆਰਗੂਮੈਂਟ ਦੀ ਲੋਡ਼ ਹੁੰਦੀ ਹੈ" \\n ਐਗਜ਼ਿਟ 1\\nfi\\n\\necho "ਆਪਟ _ ਆਰਗ1: $ਆਪਟ _ ਆਰਗ1" \\n "\'\\n ਇਸ ਉਦਾਹਰਣ ਵਿੱਚ,\' ਵਾਇਲ \'ਲੂਪ ਇਸ ਉੱਤੇ ਦੁਹਰਾਉਂਦਾ ਹੈਕਮਾਂਡ ਲਾਈਨ ਉੱਤੇ ਵਿਕਲਪ ਪਾਸ ਕੀਤੇ ਗਏ, \'ਗੇਟਓਪਟਸ\' ਦੁਆਰਾ ਪਾਰਸ ਕੀਤੇ ਗਏ। \'ਜੇਕਰ\' ਸਟੇਟਮੈਂਟ ਇਹ ਜਾਂਚਦੀ ਹੈ ਕਿ ਵਿਕਲਪ ਵਿੱਚ ਕੋਈ ਆਰਗੂਮੈਂਟ ਹੈ ਜਾਂ ਨਹੀਂ, ਅਤੇ ਜੇ ਅਜਿਹਾ ਹੈ, ਤਾਂ ਇਸ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰੋ\'ਓਪਟ _ ਆਰਗ1\' ਵੇਰੀਏਬਲ। \'ਕੇਸ\' ਸਟੇਟਮੈਂਟ ਹਰੇਕ ਵਿਕਲਪ ਅਤੇ ਇਸ ਦੇ ਸੰਭਵ ਆਰਗੂਮੈਂਟ ਨੂੰ ਸੰਭਾਲਦੀ ਹੈ। \'\\\\?\' ਸਮੀਕਰਨ ਦੀ ਵਰਤੋਂ ਗਲਤ ਨੂੰ ਸੰਭਾਲਣ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।ਚੋਣਾਂ। \\n\\n ਇਸ ਸਕ੍ਰਿਪਟ ਨੂੰ ਇਸ ਤਰ੍ਹਾਂ ਚਲਾਇਆ ਜਾ ਸਕਦਾ ਹੈਃ \\n \'\' ਬਸ਼\\ n./script.sh-a ਹੈਲੋ\\n \'\\n ਇਹ\'-a \'ਵਿਕਲਪ ਨੂੰ ਪਾਰਸ ਕਰੇਗਾ ਅਤੇ ਆਰਗੂਮੈਂਟ ਨੂੰ\' ਹੈਲੋ \'ਨਿਰਧਾਰਤ ਕਰੇਗਾ\'ਓਪਟ _ ਆਰਗ1\'। ਜੇਕਰ ਵਿਕਲਪ ਨਿਰਧਾਰਤ ਨਹੀਂ ਕੀਤਾ ਗਿਆ ਹੈ ਜਾਂ ਬਹੁਤ ਸਾਰੀਆਂ ਆਰਗੂਮੈਂਟਾਂ ਹਨ, ਤਾਂ ਇੱਕ ਗਲਤੀ ਸੁਨੇਹਾ ਪ੍ਰਦਰਸ਼ਿਤ ਕੀਤਾ ਜਾਵੇਗਾ। \',\' ਇਸ ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਕੀ ਹੈ \',\' ਇਸ ਵਿੱਚਸਕ੍ਰਿਪਟ, \'ਕੇਸ\' ਸਟੇਟਮੈਂਟ ਦੀ ਵਰਤੋਂ ਕਮਾਂਡ ਲਾਈਨ ਉੱਤੇ ਪਾਸ ਕੀਤੇ ਗਏ ਹਰੇਕ ਵਿਕਲਪ ਨੂੰ ਇਸ ਦੇ ਸੰਭਵ ਆਰਗੂਮੈਂਟ (ਜ਼) ਦੇ ਨਾਲ ਸੰਭਾਲਣ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। \'ਕੇਸ\' ਸਟੇਟਮੈਂਟ ਇੱਕ ਹੈਸ਼ੈੱਲ ਸਕ੍ਰਿਪਟਿੰਗ ਵਿੱਚ ਕੰਟਰੋਲ-ਫਲੋ ਸਟੇਟਮੈਂਟ ਜੋ ਤੁਹਾਨੂੰ ਇੱਕ ਵੇਰੀਏਬਲ ਦੇ ਮੁੱਲ ਦੇ ਅਧਾਰ ਤੇ ਚਲਾਉਣ ਲਈ ਕਮਾਂਡਾਂ ਦੀ ਇੱਕ ਲਡ਼ੀ ਨਿਰਧਾਰਤ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ ਜਾਂਸਮੀਕਰਨ. \\n\\n ਇਸ ਉਦਾਹਰਣ ਵਿੱਚ, \'ਕੇਸ\' ਸਟੇਟਮੈਂਟ ਦੀ ਵਰਤੋਂ \'ਗੇਟਓਪਟਸ\' ਕਮਾਂਡ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਕਮਾਂਡ ਲਾਈਨ ਉੱਤੇ ਪਾਸ ਕੀਤੇ ਗਏ ਵੱਖ-ਵੱਖ ਵਿਕਲਪਾਂ ਨੂੰ ਸੰਭਾਲਣ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।\'ਕੇਸ\' ਕਥਨ ਵਿੱਚ \'ਜਦੋਂ\' ਧਾਰਾਵਾਂ ਦੀ ਇੱਕ ਲਡ਼ੀ ਹੁੰਦੀ ਹੈ, ਜਿਨ੍ਹਾਂ ਵਿੱਚੋਂ ਹਰੇਕ ਨੂੰ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ ਜੇਕਰ \'OPTARG\' ਵੇਰੀਏਬਲ ਦਾ ਮੁੱਲ ਇਸ ਵਿੱਚ ਦਰਸਾਏ ਗਏ ਪੈਟਰਨ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ।\'ਕੇਸ\' ਸਟੇਟਮੈਂਟ। \\n\\n ਉਦਾਹਰਣ ਵਜੋਂ, ਪਹਿਲਾ \'ਕੇਸ\' ਸਟੇਟਮੈਂਟ ਜਾਂਚਦਾ ਹੈ ਕਿ ਕਮਾਂਡ ਲਾਈਨ ਉੱਤੇ ਪਾਸ ਕੀਤਾ ਵਿਕਲਪ \'-a\' ਹੈ ਜਾਂ ਨਹੀਂ। ਜੇ ਹੈ, ਤਾਂ \'ਜੇਕਰ\'\'ਕੇਸ\' ਸਟੇਟਮੈਂਟ ਦੇ ਅੰਦਰ ਸਟੇਟਮੈਂਟ ਇਹ ਜਾਂਚਦੀ ਹੈ ਕਿ ਕੀ \'-a\' ਵਿਕਲਪ ਲਈ ਕੋਈ ਆਰਗੂਮੈਂਟ ਹੈ। ਜੇ ਹੈ, ਤਾਂ \'ਆਪਟ _ ਆਰਗ1\' ਵੇਰੀਏਬਲ ਨਿਰਧਾਰਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।ਆਰਗੂਮੈਂਟ ਦਾ ਮੁੱਲ। \\n\\n \'ਕੇਸ\' ਸਟੇਟਮੈਂਟ ਸ਼ੈੱਲ ਸਕ੍ਰਿਪਟਿੰਗ ਵਿੱਚ ਬਹੁਤ ਸਾਰੇ ਕੰਟਰੋਲ-ਫਲੋ ਸਟੇਟਮੈਂਟਾਂ ਵਿੱਚੋਂ ਇੱਕ ਹੈ, ਅਤੇ ਇਸ ਨੂੰ ਸੰਯੋਜਨ ਵਿੱਚ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ।ਵਧੇਰੇ ਗੁੰਝਲਦਾਰ ਸਕ੍ਰਿਪਟਾਂ ਬਣਾਉਣ ਲਈ ਹੋਰ ਸਟੇਟਮੈਂਟਾਂ ਦੇ ਨਾਲ. \',\' ਮਲਟੀਪਲ ਗੇਟਓਪਟਸ ਬਣਾਓ \',\' ਤੁਸੀਂ ਇੱਕ ਸਿੰਗਲ ਸ਼ੈੱਲ ਵਿੱਚ ਮਲਟੀਪਲ \'ਗੇਟਓਪਟਸ\' ਵਿਕਲਪ ਬਣਾ ਸਕਦੇ ਹੋ।\'ਵਾਇਲ\' ਲੂਪ ਵਿੱਚ ਕਈ ਵਿਕਲਪਾਂ ਨੂੰ ਦਰਸਾ ਕੇ ਸਕ੍ਰਿਪਟ ਕਰੋ। ਉਦਾਹਰਨ ਲਈਃ \\n \'\' ਬੈਸ਼\\n #!/ਬਿਨ/ਬੈਸ਼\\n \'ਜਦੋਂ ਕਿ "a b" ਦੀ ਚੋਣ ਕਰਦਾ ਹੈ; \\n ਕੇਸ $ਦੀ ਚੋਣ ਕਰੋ \\n a) \\nਆਪਟ _ ਆਰ. ਜੀ. 1 = "$ਓ. ਪੀ. ਟੀ. ਏ. ਆਰ. ਜੀ". \\n; \\n b) \\n ਆਪਟ _ ਆਰ. ਜੀ. 2 = "$ਓ. ਪੀ. ਟੀ. ਏ. ਆਰ. ਜੀ". \\n; \\n\\\\?ਇਸ ਉਦਾਹਰਣ ਵਿੱਚ, \'ਵਾਇਲ\' ਲੂਪ ਦੋ ਵਿਕਲਪਾਂ \'ਤੇ ਦੁਹਰਾਉਂਦਾ ਹੈਃ\'-a \'ਅਤੇ\'-b \'.\' ਕੇਸ \'ਸਟੇਟਮੈਂਟ ਹੈਂਡਲ ਕਰਦੇ ਹਨਹਰੇਕ ਵਿਕਲਪ ਅਤੇ ਇਸ ਦੀ ਸੰਭਵ ਦਲੀਲ, ਜਿਵੇਂ ਕਿ ਪਿਛਲੀ ਉਦਾਹਰਣ ਵਿੱਚ। \\n\\n ਇਸ ਸਕ੍ਰਿਪਟ ਨੂੰ ਚਲਾਉਣ ਲਈ, ਤੁਸੀਂ ਹੇਠ ਲਿਖਿਆਂ ਦੀ ਵਰਤੋਂ ਕਰੋਗੇਃਕਮਾਂਡਃ \'\\n\' \'bash\\ n./script.sh-a ਹੈਲੋ-b ਸੰਸਾਰ \\n\' \'\\n ਇਹ\' ਹੈਲੋ \'ਅਤੇ\' ਸੰਸਾਰ \'ਦੇ ਮੁੱਲ ਕ੍ਰਮਵਾਰ\' ਆਪਟ _ ਆਰਗ1 \'ਅਤੇ\' ਆਪਟ _ ਆਰਗ2 \'ਨੂੰ ਨਿਰਧਾਰਤ ਕਰੇਗਾ। ਜੇਕਰਕੋਈ ਵੀ ਗਲਤ ਵਿਕਲਪ ਨਿਰਧਾਰਤ ਕੀਤਾ ਗਿਆ ਹੈ, ਇੱਕ ਗਲਤੀ ਸੁਨੇਹਾ ਪ੍ਰਦਰਸ਼ਿਤ ਕੀਤਾ ਜਾਵੇਗਾ। \',\' ਜਾਂਚ ਕਰੋ ਕਿ ਕੀ ਗੇਟਓਪਟਸ ਦਿੱਤੇ ਗਏ ਹਨ ਜੇ ਗਲਤੀ ਨਹੀਂ ਦਿਖਾਈ ਦਿੰਦੀ \',\' ਜਾਂਚ ਕਰਨ ਲਈ ਕਿ ਕੀ \'ਗੇਟਓਪਟਸ\'ਵਿਕਲਪ ਦਿੱਤੇ ਗਏ ਹਨ, ਤੁਸੀਂ ਇਹ ਜਾਂਚ ਕਰਨ ਲਈ ਇੱਕ ਸਧਾਰਨ \'ਜੇਕਰ\' ਸਟੇਟਮੈਂਟ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ ਕਿ ਕੀ \'ਓ. ਪੀ. ਟੀ. ਆਈ. ਐੱਨ. ਡੀ.\' ਵੇਰੀਏਬਲ ਜ਼ੀਰੋ ਤੋਂ ਵੱਡਾ ਹੈ।ਉਦਾਹਰਨਃ \\n "\'ਬੈਸ਼\\n #!/ਬਿਨ/ਬੈਸ਼\\n\\nif [$#-gt0]; ਫਿਰ \\n ਜਦੋਂ ਕਿ" a b "ਦੀ ਚੋਣ ਕਰਦਾ ਹੈ; \\n ਕੇਸ $ਦੀ ਚੋਣ ਕਰੋ \\n a) \\n ਆਪਟ _ ਆਰਗ1 =" $OPTARG "\\n; \\n b) \\nਆਪਟ _ ਆਰਜੀ2 = "$ਓਪੀਟੀਏਆਰਜੀ" \\n; \\n\\\\?) \\n ਇਕੋ ਗਲਤੀਃ ਗਲਤ ਵਿਕਲਪ-$ਓਪੀਟੀਏਆਰਜੀ "\\n ਐਗਜ਼ਿਟ 1\\n; \\n ਈਐੱਸਏਸੀ\\ਨ ਕੀਤਾ ਗਿਆ \\n\\n ਜੇਕਰ [-z" $ਆਪਟ _ ਆਰਜੀ1 "]।। [-z" $ਆਪਟ _ ਆਰਜੀ2 "];ਫਿਰ \\n echo "ਗਲਤੀਃ ਦੋਵੇਂ ਵਿਕਲਪ-a ਅਤੇ-b ਦੀ ਜ਼ਰੂਰਤ ਹੈ" \\n ਐਗਜ਼ਿਟ 1\\n ਫਾਈ\\ਨ\\ਨ ਈਕੋ "ਆਪਟ _ ਆਰਗ1: $ਆਪਟ _ ਆਰਗ1" \\ਨ ਈਕੋ "ਆਪਟ _ ਆਰਗ2: $ਆਪਟ _ ਆਰਗ2" \\ਨਫੀ\\ਨ "\\ਨ ਇਸ ਵਿੱਚਸਕ੍ਰਿਪਟ, \'ਜੇਕਰ\' ਸਟੇਟਮੈਂਟ ਜਾਂਚਦਾ ਹੈ ਕਿ ਕੀ ਕਮਾਂਡ ਲਾਈਨ ਉੱਤੇ ਕੋਈ ਵਿਕਲਪ ਦਿੱਤੇ ਗਏ ਹਨ। ਜੇਕਰ \'ਓ. ਪੀ. ਟੀ. ਆਈ. ਐੱਨ. ਡੀ.\' ਵੇਰੀਏਬਲ (ਜੋ \'ਗੇਟਓਪਟਸ\' ਦੁਆਰਾ ਸੈੱਟ ਕੀਤਾ ਗਿਆ ਹੈ) ਹੈਜ਼ੀਰੋ ਤੋਂ ਵੱਡਾ, ਫਿਰ ਵਿਕਲਪਾਂ ਨੂੰ ਸੰਭਾਲਣ ਲਈ \'ਵਾਇਲ\' ਲੂਪ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ। ਜੇਕਰ ਕੋਈ ਵਿਕਲਪ ਨਹੀਂ ਦਿੱਤਾ ਜਾਂਦਾ, ਤਾਂ ਇੱਕ ਗਲਤੀ ਸੁਨੇਹਾ ਪ੍ਰਦਰਸ਼ਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। \\n\\n ਨੋਟ ਕਰੋ ਕਿ\'ਜੇਕਰ\' ਬਿਆਨ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਜ਼ਰੂਰੀ ਹੈ ਕਿ \'ਵਾਇਲ\' ਲੂਪ ਸਿਰਫ ਤਾਂ ਹੀ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ ਜੇ ਵਿਕਲਪ ਪ੍ਰਦਾਨ ਕੀਤੇ ਗਏ ਹਨ। ਜੇ \'ਜੇਕਰ\' ਬਿਆਨ ਨੂੰ ਛੱਡ ਦਿੱਤਾ ਗਿਆ ਸੀ,\'ਵਾਇਲ\' ਲੂਪ ਅਜੇ ਵੀ ਚੱਲੇਗਾ ਭਾਵੇਂ ਕੋਈ ਵਿਕਲਪ ਨਿਰਧਾਰਤ ਨਹੀਂ ਕੀਤੇ ਗਏ ਸਨ, ਜੋ ਅਚਾਨਕ ਵਿਵਹਾਰ ਵੱਲ ਲੈ ਜਾ ਸਕਦੇ ਹਨ। \',\' ਕਈ ਵਿਕਲਪ ਬਣਾਉਂਦੇ ਹਨ ਜੋ ਲੈਂਦੇ ਹਨਮਲਟੀਪਲ ਆਰਗੂਮੈਂਟ ਅਤੇ ਗਲਤੀ ਦਿਖਾਉਂਦਾ ਹੈ ਜੇ ਕੋਈ ਵਿਕਲਪ ਜਾਂ ਆਰਗੂਮੈਂਟ ਨਹੀਂ ਦਿੱਤੇ ਗਏ ਹਨ \',\' ਮਲਟੀਪਲ \'ਗੇਟਓਪਟਸ\' ਵਿਕਲਪ ਬਣਾਉਣ ਲਈ ਜੋ ਮਲਟੀਪਲ ਆਰਗੂਮੈਂਟ ਲੈਂਦੇ ਹਨ ਅਤੇਜੇਕਰ ਕੋਈ ਵਿਕਲਪ ਜਾਂ ਆਰਗੂਮੈਂਟ ਨਹੀਂ ਦਿੱਤੇ ਗਏ ਹਨ, ਤਾਂ ਤੁਸੀਂ \'ਜਦੋਂ\' ਲੂਪਸ ਅਤੇ \'ਲੂਪਸ ਲਈ\' ਦੇ ਸੁਮੇਲ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ, ਨਾਲ ਹੀ \'ਜੇਕਰ\' ਸਟੇਟਮੈਂਟਾਂ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ।ਦਿੱਤੀਆਂ ਗਈਆਂ ਆਰਗੂਮੈਂਟਾਂ ਦੀ ਗਿਣਤੀ ਦੀ ਜਾਂਚ ਕਰੋ। ਇੱਥੇ ਇੱਕ ਉਦਾਹਰਨ ਹੈਃ \\n "\'ਬੈਸ਼\\n #!/ਬਿਨ/ਬੈਸ਼\\n\' ਜਦੋਂ ਕਿ" a b c d "ਦੀ ਚੋਣ ਕਰਦਾ ਹੈ; \\n ਕੇਸ $ਦੀ ਚੋਣ ਕਰੋ \\n a) \\n ਜੇਕਰ [$#-lt2]; ਫਿਰ \\n echo "ਗਲਤੀਃ ਵਿਕਲਪ-a ਲਈ ਦੋ ਆਰਗੂਮੈਂਟਾਂ ਦੀ ਲੋਡ਼ ਹੈ" \\n ਨਿਕਾਸ 1\\n ਫਾਈ\\ਨ ਆਪਟ _ ਆਰਗ1 = "$OPTARG" \\n ਆਪਟ _ ਆਰਗ2 = "$OPTARG" \\n;; \\n b) \\n ਜੇਕਰ [$#-lt2]; ਫਿਰ \\necho "ਗਲਤੀਃ ਵਿਕਲਪ-b ਲਈ ਦੋ ਆਰਗੂਮੈਂਟਾਂ ਦੀ ਲੋਡ਼ ਹੈ" \\n ਐਗਜ਼ਿਟ 1\\n ਫਾਈ\\ਨ ਆਪਟ _ ਆਰਗ1 = "$OPTARG" \\n ਆਪਟ _ ਆਰਗ2 = "$OPTARG" \\n; \\nc) \\n ਜੇਕਰ [$#-lt3]; ਫਿਰ \\n ਈਕੋ"ਗਲਤੀਃ ਚੋਣ-c ਲਈ ਤਿੰਨ ਆਰਗੂਮੈਂਟਾਂ ਦੀ ਲੋਡ਼ ਹੁੰਦੀ ਹੈ" \\n ਐਗਜ਼ਿਟ 1\\n ਫਾਈ\\ਨ ਆਪਟ _ ਆਰਗ1 = "$OPTARG" \\n ਆਪਟ _ ਆਰਗ2 = "$OPTARG" \\n ਆਪਟ _ ਆਰਗ3 = "$OPTARG" \\n; \\n d) \\n ਜੇਕਰ [$#-lt2];ਫਿਰ \\n echo "ਗਲਤੀਃ ਵਿਕਲਪ-d ਲਈ ਦੋ ਆਰਗੂਮੈਂਟਾਂ ਦੀ ਲੋਡ਼ ਹੈ" \\n ਐਗਜ਼ਿਟ 1\\n ਫਾਈ\\ਨ ਆਪਟ _ ਆਰਗ1 = "$OPTARG" \\n ਆਪਟ _ ਆਰਗ2 = "$OPTARG" \\n; \\n\\\\?ਚੋਣ-$OPTARG "\\n ਐਗਜ਼ਿਟ 1\\n; \\n eSAC\\ndone\\n\\nif [-z" $opt _ arg1 "]।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।ਵਿਕਲਪ ਆਰਗੂਮੈਂਟ ਗੁੰਮ ਹੈ "\\n ਐਗਜ਼ਿਟ 1\\nfi\\n\\necho" ਆਪਟ _ ਆਰਜੀ1: $ਆਪਟ _ ਆਰਜੀ1 "\\necho" ਆਪਟ _ ਆਰਜੀ2: $ਆਪਟ _ ਆਰਜੀ2 "\\necho" ਆਪਟ _ ਆਰਜੀ3: $ਆਪਟ _ ਆਰਜੀ3 "\\n" \\n ਇਸ ਸਕ੍ਰਿਪਟ ਵਿੱਚ,\'ਵਾਇਲ\' ਲੂਪ ਚਾਰ ਵਿਕਲਪਾਂ ਉੱਤੇ ਦੁਹਰਾਉਂਦਾ ਹੈਃ \'-a\', \'-b\', \'-c\', ਅਤੇ \'-d\'. \',\' ਉੱਪਰਲੀ ਸਕ੍ਰਿਪਟ ਨੂੰ-- ark ਵਿਕਲਪ ਨਾਲ ਬਣਾਓ ਜੋ-a ਵਿਕਲਪ ਵਾਂਗ ਕੰਮ ਕਰਦਾ ਹੈ \'] ', 'ਸ਼ੈੱਲ ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਗੇਟਓਪਟਸ ਦੀ ਵਰਤੋਂ ਕਿਵੇਂ ਕਰਨੀ ਹੈ', ' [\'ਸ਼ੈੱਲ ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਗੇਟਓਪਟਸ ਦੀ ਵਰਤੋਂ ਕਿਵੇਂ ਕਰਨੀ ਹੈ\', \'ਗੇਟਓਪਟਸ\' ਯੂਨਿਕਸ ਸ਼ੈੱਲ ਸਕ੍ਰਿਪਟਾਂ ਵਿੱਚ ਇੱਕ ਕਮਾਂਡ-ਲਾਈਨ ਵਿਕਲਪ ਪਾਰਸ ਕਰਨ ਦਾ ਟੂਲ ਹੈ। ਇਹ ਤੁਹਾਨੂੰ ਵਿਕਲਪਾਂ ਅਤੇ ਵਿਕਲਪਾਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ।ਤੁਹਾਡੀ ਸਕ੍ਰਿਪਟ ਲਈ ਆਰਗੂਮੈਂਟ, ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਕਮਾਂਡ ਲਾਈਨ ਤੋਂ ਪਾਰਸ ਕਰੋ। ਇੱਥੇ ਇੱਕ ਉਦਾਹਰਣ ਹੈ ਕਿ ਸ਼ੈੱਲ ਵਿੱਚ \'ਗੇਟਓਪਟਸ\' ਦੀ ਵਰਤੋਂ ਕਿਵੇਂ ਕਰਨੀ ਹੈ।ਸਕ੍ਰਿਪਟਃ \'\\n\' \'ਬਸ਼ \\n #!/ਬਿਨ/ਬਸ਼ \\n\' ਜਦੋਂ ਕਿ "a" ਦੀ ਚੋਣ ਕਰਦਾ ਹੈ; \\n ਕੇਸ $ਦੀ ਚੋਣ ਕਰੋ \\n a) \\n ਜੇਕਰ [$#-gt 1]; ਤਾਂ \\n ਗੂੰਜ "ਗਲਤੀਃ ਵਿਕਲਪ ਲਈ ਬਹੁਤ ਸਾਰੀਆਂ ਆਰਗੂਮੈਂਟਾਂ- a "\\n ਨਿਕਾਸ 1\\n ਫਾਈ\\ਨ ਆਪਟ _ ਆਰਗ1 =" $OPTARG "\\n;; \\n\\\\?) \\n ਗੂੰਜ" ਗਲਤੀਃ ਗਲਤ ਵਿਕਲਪ-$OPTARG "\\n ਨਿਕਾਸ 1\\n; \\n eSAC\\ndone\\n\\nif [-z" $ਆਪਟ _ ਆਰਗ1 "]; ਫਿਰ \\necho "ਗਲਤੀਃ ਵਿਕਲਪ-a ਲਈ ਇੱਕ ਆਰਗੂਮੈਂਟ ਦੀ ਲੋਡ਼ ਹੁੰਦੀ ਹੈ" \\n ਐਗਜ਼ਿਟ 1\\nfi\\n\\necho "ਆਪਟ _ ਆਰਗ1: $ਆਪਟ _ ਆਰਗ1" \\n "\'\\n ਇਸ ਉਦਾਹਰਣ ਵਿੱਚ,\' ਵਾਇਲ \'ਲੂਪ ਇਸ ਉੱਤੇ ਦੁਹਰਾਉਂਦਾ ਹੈਕਮਾਂਡ ਲਾਈਨ ਉੱਤੇ ਵਿਕਲਪ ਪਾਸ ਕੀਤੇ ਗਏ, \'ਗੇਟਓਪਟਸ\' ਦੁਆਰਾ ਪਾਰਸ ਕੀਤੇ ਗਏ। \'ਜੇਕਰ\' ਸਟੇਟਮੈਂਟ ਇਹ ਜਾਂਚਦੀ ਹੈ ਕਿ ਵਿਕਲਪ ਵਿੱਚ ਕੋਈ ਆਰਗੂਮੈਂਟ ਹੈ ਜਾਂ ਨਹੀਂ, ਅਤੇ ਜੇ ਅਜਿਹਾ ਹੈ, ਤਾਂ ਇਸ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰੋ\'ਓਪਟ _ ਆਰਗ1\' ਵੇਰੀਏਬਲ। \'ਕੇਸ\' ਸਟੇਟਮੈਂਟ ਹਰੇਕ ਵਿਕਲਪ ਅਤੇ ਇਸ ਦੇ ਸੰਭਵ ਆਰਗੂਮੈਂਟ ਨੂੰ ਸੰਭਾਲਦੀ ਹੈ। \'\\\\?\' ਸਮੀਕਰਨ ਦੀ ਵਰਤੋਂ ਗਲਤ ਨੂੰ ਸੰਭਾਲਣ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।ਚੋਣਾਂ। \\n\\n ਇਸ ਸਕ੍ਰਿਪਟ ਨੂੰ ਇਸ ਤਰ੍ਹਾਂ ਚਲਾਇਆ ਜਾ ਸਕਦਾ ਹੈਃ \\n \'\' ਬਸ਼\\ n./script.sh-a ਹੈਲੋ\\n \'\\n ਇਹ\'-a \'ਵਿਕਲਪ ਨੂੰ ਪਾਰਸ ਕਰੇਗਾ ਅਤੇ ਆਰਗੂਮੈਂਟ ਨੂੰ\' ਹੈਲੋ \'ਨਿਰਧਾਰਤ ਕਰੇਗਾ\'ਓਪਟ _ ਆਰਗ1\'। ਜੇਕਰ ਵਿਕਲਪ ਨਿਰਧਾਰਤ ਨਹੀਂ ਕੀਤਾ ਗਿਆ ਹੈ ਜਾਂ ਬਹੁਤ ਸਾਰੀਆਂ ਆਰਗੂਮੈਂਟਾਂ ਹਨ, ਤਾਂ ਇੱਕ ਗਲਤੀ ਸੁਨੇਹਾ ਪ੍ਰਦਰਸ਼ਿਤ ਕੀਤਾ ਜਾਵੇਗਾ। \',\' ਇਸ ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਕੀ ਹੈ \',\' ਇਸ ਵਿੱਚਸਕ੍ਰਿਪਟ, \'ਕੇਸ\' ਸਟੇਟਮੈਂਟ ਦੀ ਵਰਤੋਂ ਕਮਾਂਡ ਲਾਈਨ ਉੱਤੇ ਪਾਸ ਕੀਤੇ ਗਏ ਹਰੇਕ ਵਿਕਲਪ ਨੂੰ ਇਸ ਦੇ ਸੰਭਵ ਆਰਗੂਮੈਂਟ (ਜ਼) ਦੇ ਨਾਲ ਸੰਭਾਲਣ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। \'ਕੇਸ\' ਸਟੇਟਮੈਂਟ ਇੱਕ ਹੈਸ਼ੈੱਲ ਸਕ੍ਰਿਪਟਿੰਗ ਵਿੱਚ ਕੰਟਰੋਲ-ਫਲੋ ਸਟੇਟਮੈਂਟ ਜੋ ਤੁਹਾਨੂੰ ਇੱਕ ਵੇਰੀਏਬਲ ਦੇ ਮੁੱਲ ਦੇ ਅਧਾਰ ਤੇ ਚਲਾਉਣ ਲਈ ਕਮਾਂਡਾਂ ਦੀ ਇੱਕ ਲਡ਼ੀ ਨਿਰਧਾਰਤ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ ਜਾਂਸਮੀਕਰਨ. \\n\\n ਇਸ ਉਦਾਹਰਣ ਵਿੱਚ, \'ਕੇਸ\' ਸਟੇਟਮੈਂਟ ਦੀ ਵਰਤੋਂ \'ਗੇਟਓਪਟਸ\' ਕਮਾਂਡ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਕਮਾਂਡ ਲਾਈਨ ਉੱਤੇ ਪਾਸ ਕੀਤੇ ਗਏ ਵੱਖ-ਵੱਖ ਵਿਕਲਪਾਂ ਨੂੰ ਸੰਭਾਲਣ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।\'ਕੇਸ\' ਕਥਨ ਵਿੱਚ \'ਜਦੋਂ\' ਧਾਰਾਵਾਂ ਦੀ ਇੱਕ ਲਡ਼ੀ ਹੁੰਦੀ ਹੈ, ਜਿਨ੍ਹਾਂ ਵਿੱਚੋਂ ਹਰੇਕ ਨੂੰ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ ਜੇਕਰ \'OPTARG\' ਵੇਰੀਏਬਲ ਦਾ ਮੁੱਲ ਇਸ ਵਿੱਚ ਦਰਸਾਏ ਗਏ ਪੈਟਰਨ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ।\'ਕੇਸ\' ਸਟੇਟਮੈਂਟ। \\n\\n ਉਦਾਹਰਣ ਵਜੋਂ, ਪਹਿਲਾ \'ਕੇਸ\' ਸਟੇਟਮੈਂਟ ਜਾਂਚਦਾ ਹੈ ਕਿ ਕਮਾਂਡ ਲਾਈਨ ਉੱਤੇ ਪਾਸ ਕੀਤਾ ਵਿਕਲਪ \'-a\' ਹੈ ਜਾਂ ਨਹੀਂ। ਜੇ ਹੈ, ਤਾਂ \'ਜੇਕਰ\'\'ਕੇਸ\' ਸਟੇਟਮੈਂਟ ਦੇ ਅੰਦਰ ਸਟੇਟਮੈਂਟ ਇਹ ਜਾਂਚਦੀ ਹੈ ਕਿ ਕੀ \'-a\' ਵਿਕਲਪ ਲਈ ਕੋਈ ਆਰਗੂਮੈਂਟ ਹੈ। ਜੇ ਹੈ, ਤਾਂ \'ਆਪਟ _ ਆਰਗ1\' ਵੇਰੀਏਬਲ ਨਿਰਧਾਰਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।ਆਰਗੂਮੈਂਟ ਦਾ ਮੁੱਲ। \\n\\n \'ਕੇਸ\' ਸਟੇਟਮੈਂਟ ਸ਼ੈੱਲ ਸਕ੍ਰਿਪਟਿੰਗ ਵਿੱਚ ਬਹੁਤ ਸਾਰੇ ਕੰਟਰੋਲ-ਫਲੋ ਸਟੇਟਮੈਂਟਾਂ ਵਿੱਚੋਂ ਇੱਕ ਹੈ, ਅਤੇ ਇਸ ਨੂੰ ਸੰਯੋਜਨ ਵਿੱਚ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ।ਵਧੇਰੇ ਗੁੰਝਲਦਾਰ ਸਕ੍ਰਿਪਟਾਂ ਬਣਾਉਣ ਲਈ ਹੋਰ ਸਟੇਟਮੈਂਟਾਂ ਦੇ ਨਾਲ. \',\' ਮਲਟੀਪਲ ਗੇਟਓਪਟਸ ਬਣਾਓ \',\' ਤੁਸੀਂ ਇੱਕ ਸਿੰਗਲ ਸ਼ੈੱਲ ਵਿੱਚ ਮਲਟੀਪਲ \'ਗੇਟਓਪਟਸ\' ਵਿਕਲਪ ਬਣਾ ਸਕਦੇ ਹੋ।\'ਵਾਇਲ\' ਲੂਪ ਵਿੱਚ ਕਈ ਵਿਕਲਪਾਂ ਨੂੰ ਦਰਸਾ ਕੇ ਸਕ੍ਰਿਪਟ ਕਰੋ। ਉਦਾਹਰਨ ਲਈਃ \\n \'\' ਬੈਸ਼\\n #!/ਬਿਨ/ਬੈਸ਼\\n \'ਜਦੋਂ ਕਿ "a b" ਦੀ ਚੋਣ ਕਰਦਾ ਹੈ; \\n ਕੇਸ $ਦੀ ਚੋਣ ਕਰੋ \\n a) \\nਆਪਟ _ ਆਰ. ਜੀ. 1 = "$ਓ. ਪੀ. ਟੀ. ਏ. ਆਰ. ਜੀ". \\n; \\n b) \\n ਆਪਟ _ ਆਰ. ਜੀ. 2 = "$ਓ. ਪੀ. ਟੀ. ਏ. ਆਰ. ਜੀ". \\n; \\n\\\\?ਇਸ ਉਦਾਹਰਣ ਵਿੱਚ, \'ਵਾਇਲ\' ਲੂਪ ਦੋ ਵਿਕਲਪਾਂ \'ਤੇ ਦੁਹਰਾਉਂਦਾ ਹੈਃ\'-a \'ਅਤੇ\'-b \'.\' ਕੇਸ \'ਸਟੇਟਮੈਂਟ ਹੈਂਡਲ ਕਰਦੇ ਹਨਹਰੇਕ ਵਿਕਲਪ ਅਤੇ ਇਸ ਦੀ ਸੰਭਵ ਦਲੀਲ, ਜਿਵੇਂ ਕਿ ਪਿਛਲੀ ਉਦਾਹਰਣ ਵਿੱਚ। \\n\\n ਇਸ ਸਕ੍ਰਿਪਟ ਨੂੰ ਚਲਾਉਣ ਲਈ, ਤੁਸੀਂ ਹੇਠ ਲਿਖਿਆਂ ਦੀ ਵਰਤੋਂ ਕਰੋਗੇਃਕਮਾਂਡਃ \'\\n\' \'bash\\ n./script.sh-a ਹੈਲੋ-b ਸੰਸਾਰ \\n\' \'\\n ਇਹ\' ਹੈਲੋ \'ਅਤੇ\' ਸੰਸਾਰ \'ਦੇ ਮੁੱਲ ਕ੍ਰਮਵਾਰ\' ਆਪਟ _ ਆਰਗ1 \'ਅਤੇ\' ਆਪਟ _ ਆਰਗ2 \'ਨੂੰ ਨਿਰਧਾਰਤ ਕਰੇਗਾ। ਜੇਕਰਕੋਈ ਵੀ ਗਲਤ ਵਿਕਲਪ ਨਿਰਧਾਰਤ ਕੀਤਾ ਗਿਆ ਹੈ, ਇੱਕ ਗਲਤੀ ਸੁਨੇਹਾ ਪ੍ਰਦਰਸ਼ਿਤ ਕੀਤਾ ਜਾਵੇਗਾ। \',\' ਜਾਂਚ ਕਰੋ ਕਿ ਕੀ ਗੇਟਓਪਟਸ ਦਿੱਤੇ ਗਏ ਹਨ ਜੇ ਗਲਤੀ ਨਹੀਂ ਦਿਖਾਈ ਦਿੰਦੀ \',\' ਜਾਂਚ ਕਰਨ ਲਈ ਕਿ ਕੀ \'ਗੇਟਓਪਟਸ\'ਵਿਕਲਪ ਦਿੱਤੇ ਗਏ ਹਨ, ਤੁਸੀਂ ਇਹ ਜਾਂਚ ਕਰਨ ਲਈ ਇੱਕ ਸਧਾਰਨ \'ਜੇਕਰ\' ਸਟੇਟਮੈਂਟ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ ਕਿ ਕੀ \'ਓ. ਪੀ. ਟੀ. ਆਈ. ਐੱਨ. ਡੀ.\' ਵੇਰੀਏਬਲ ਜ਼ੀਰੋ ਤੋਂ ਵੱਡਾ ਹੈ।ਉਦਾਹਰਨਃ \\n "\'ਬੈਸ਼\\n #!/ਬਿਨ/ਬੈਸ਼\\n\\nif [$#-gt0]; ਫਿਰ \\n ਜਦੋਂ ਕਿ" a b "ਦੀ ਚੋਣ ਕਰਦਾ ਹੈ; \\n ਕੇਸ $ਦੀ ਚੋਣ ਕਰੋ \\n a) \\n ਆਪਟ _ ਆਰਗ1 =" $OPTARG "\\n; \\n b) \\nਆਪਟ _ ਆਰਜੀ2 = "$ਓਪੀਟੀਏਆਰਜੀ" \\n; \\n\\\\?) \\n ਇਕੋ ਗਲਤੀਃ ਗਲਤ ਵਿਕਲਪ-$ਓਪੀਟੀਏਆਰਜੀ "\\n ਐਗਜ਼ਿਟ 1\\n; \\n ਈਐੱਸਏਸੀ\\ਨ ਕੀਤਾ ਗਿਆ \\n\\n ਜੇਕਰ [-z" $ਆਪਟ _ ਆਰਜੀ1 "]।। [-z" $ਆਪਟ _ ਆਰਜੀ2 "];ਫਿਰ \\n echo "ਗਲਤੀਃ ਦੋਵੇਂ ਵਿਕਲਪ-a ਅਤੇ-b ਦੀ ਜ਼ਰੂਰਤ ਹੈ" \\n ਐਗਜ਼ਿਟ 1\\n ਫਾਈ\\ਨ\\ਨ ਈਕੋ "ਆਪਟ _ ਆਰਗ1: $ਆਪਟ _ ਆਰਗ1" \\ਨ ਈਕੋ "ਆਪਟ _ ਆਰਗ2: $ਆਪਟ _ ਆਰਗ2" \\ਨਫੀ\\ਨ "\\ਨ ਇਸ ਵਿੱਚਸਕ੍ਰਿਪਟ, \'ਜੇਕਰ\' ਸਟੇਟਮੈਂਟ ਜਾਂਚਦਾ ਹੈ ਕਿ ਕੀ ਕਮਾਂਡ ਲਾਈਨ ਉੱਤੇ ਕੋਈ ਵਿਕਲਪ ਦਿੱਤੇ ਗਏ ਹਨ। ਜੇਕਰ \'ਓ. ਪੀ. ਟੀ. ਆਈ. ਐੱਨ. ਡੀ.\' ਵੇਰੀਏਬਲ (ਜੋ \'ਗੇਟਓਪਟਸ\' ਦੁਆਰਾ ਸੈੱਟ ਕੀਤਾ ਗਿਆ ਹੈ) ਹੈਜ਼ੀਰੋ ਤੋਂ ਵੱਡਾ, ਫਿਰ ਵਿਕਲਪਾਂ ਨੂੰ ਸੰਭਾਲਣ ਲਈ \'ਵਾਇਲ\' ਲੂਪ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ। ਜੇਕਰ ਕੋਈ ਵਿਕਲਪ ਨਹੀਂ ਦਿੱਤਾ ਜਾਂਦਾ, ਤਾਂ ਇੱਕ ਗਲਤੀ ਸੁਨੇਹਾ ਪ੍ਰਦਰਸ਼ਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। \\n\\n ਨੋਟ ਕਰੋ ਕਿ\'ਜੇਕਰ\' ਬਿਆਨ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਜ਼ਰੂਰੀ ਹੈ ਕਿ \'ਵਾਇਲ\' ਲੂਪ ਸਿਰਫ ਤਾਂ ਹੀ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ ਜੇ ਵਿਕਲਪ ਪ੍ਰਦਾਨ ਕੀਤੇ ਗਏ ਹਨ। ਜੇ \'ਜੇਕਰ\' ਬਿਆਨ ਨੂੰ ਛੱਡ ਦਿੱਤਾ ਗਿਆ ਸੀ,\'ਵਾਇਲ\' ਲੂਪ ਅਜੇ ਵੀ ਚੱਲੇਗਾ ਭਾਵੇਂ ਕੋਈ ਵਿਕਲਪ ਨਿਰਧਾਰਤ ਨਹੀਂ ਕੀਤੇ ਗਏ ਸਨ, ਜੋ ਅਚਾਨਕ ਵਿਵਹਾਰ ਵੱਲ ਲੈ ਜਾ ਸਕਦੇ ਹਨ। \',\' ਕਈ ਵਿਕਲਪ ਬਣਾਉਂਦੇ ਹਨ ਜੋ ਲੈਂਦੇ ਹਨਮਲਟੀਪਲ ਆਰਗੂਮੈਂਟ ਅਤੇ ਗਲਤੀ ਦਿਖਾਉਂਦਾ ਹੈ ਜੇ ਕੋਈ ਵਿਕਲਪ ਜਾਂ ਆਰਗੂਮੈਂਟ ਨਹੀਂ ਦਿੱਤੇ ਗਏ ਹਨ \',\' ਮਲਟੀਪਲ \'ਗੇਟਓਪਟਸ\' ਵਿਕਲਪ ਬਣਾਉਣ ਲਈ ਜੋ ਮਲਟੀਪਲ ਆਰਗੂਮੈਂਟ ਲੈਂਦੇ ਹਨ ਅਤੇਜੇਕਰ ਕੋਈ ਵਿਕਲਪ ਜਾਂ ਆਰਗੂਮੈਂਟ ਨਹੀਂ ਦਿੱਤੇ ਗਏ ਹਨ, ਤਾਂ ਤੁਸੀਂ \'ਜਦੋਂ\' ਲੂਪਸ ਅਤੇ \'ਲੂਪਸ ਲਈ\' ਦੇ ਸੁਮੇਲ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ, ਨਾਲ ਹੀ \'ਜੇਕਰ\' ਸਟੇਟਮੈਂਟਾਂ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ।ਦਿੱਤੀਆਂ ਗਈਆਂ ਆਰਗੂਮੈਂਟਾਂ ਦੀ ਗਿਣਤੀ ਦੀ ਜਾਂਚ ਕਰੋ। ਇੱਥੇ ਇੱਕ ਉਦਾਹਰਨ ਹੈਃ \\n "\'ਬੈਸ਼\\n #!/ਬਿਨ/ਬੈਸ਼\\n\' ਜਦੋਂ ਕਿ" a b c d "ਦੀ ਚੋਣ ਕਰਦਾ ਹੈ; \\n ਕੇਸ $ਦੀ ਚੋਣ ਕਰੋ \\n a) \\n ਜੇਕਰ [$#-lt2]; ਫਿਰ \\n echo "ਗਲਤੀਃ ਵਿਕਲਪ-a ਲਈ ਦੋ ਆਰਗੂਮੈਂਟਾਂ ਦੀ ਲੋਡ਼ ਹੈ" \\n ਨਿਕਾਸ 1\\n ਫਾਈ\\ਨ ਆਪਟ _ ਆਰਗ1 = "$OPTARG" \\n ਆਪਟ _ ਆਰਗ2 = "$OPTARG" \\n;; \\n b) \\n ਜੇਕਰ [$#-lt2]; ਫਿਰ \\necho "ਗਲਤੀਃ ਵਿਕਲਪ-b ਲਈ ਦੋ ਆਰਗੂਮੈਂਟਾਂ ਦੀ ਲੋਡ਼ ਹੈ" \\n ਐਗਜ਼ਿਟ 1\\n ਫਾਈ\\ਨ ਆਪਟ _ ਆਰਗ1 = "$OPTARG" \\n ਆਪਟ _ ਆਰਗ2 = "$OPTARG" \\n; \\nc) \\n ਜੇਕਰ [$#-lt3]; ਫਿਰ \\n ਈਕੋ"ਗਲਤੀਃ ਚੋਣ-c ਲਈ ਤਿੰਨ ਆਰਗੂਮੈਂਟਾਂ ਦੀ ਲੋਡ਼ ਹੁੰਦੀ ਹੈ" \\n ਐਗਜ਼ਿਟ 1\\n ਫਾਈ\\ਨ ਆਪਟ _ ਆਰਗ1 = "$OPTARG" \\n ਆਪਟ _ ਆਰਗ2 = "$OPTARG" \\n ਆਪਟ _ ਆਰਗ3 = "$OPTARG" \\n; \\n d) \\n ਜੇਕਰ [$#-lt2];ਫਿਰ \\n echo "ਗਲਤੀਃ ਵਿਕਲਪ-d ਲਈ ਦੋ ਆਰਗੂਮੈਂਟਾਂ ਦੀ ਲੋਡ਼ ਹੈ" \\n ਐਗਜ਼ਿਟ 1\\n ਫਾਈ\\ਨ ਆਪਟ _ ਆਰਗ1 = "$OPTARG" \\n ਆਪਟ _ ਆਰਗ2 = "$OPTARG" \\n; \\n\\\\?ਚੋਣ-$OPTARG "\\n ਐਗਜ਼ਿਟ 1\\n; \\n eSAC\\ndone\\n\\nif [-z" $opt _ arg1 "]।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।।ਵਿਕਲਪ ਆਰਗੂਮੈਂਟ ਗੁੰਮ ਹੈ "\\n ਐਗਜ਼ਿਟ 1\\nfi\\n\\necho" ਆਪਟ _ ਆਰਜੀ1: $ਆਪਟ _ ਆਰਜੀ1 "\\necho" ਆਪਟ _ ਆਰਜੀ2: $ਆਪਟ _ ਆਰਜੀ2 "\\necho" ਆਪਟ _ ਆਰਜੀ3: $ਆਪਟ _ ਆਰਜੀ3 "\\n" \\n ਇਸ ਸਕ੍ਰਿਪਟ ਵਿੱਚ,\'ਵਾਇਲ\' ਲੂਪ ਚਾਰ ਵਿਕਲਪਾਂ ਉੱਤੇ ਦੁਹਰਾਉਂਦਾ ਹੈਃ \'-a\', \'-b\', \'-c\', ਅਤੇ \'-d\'. \',\' ਉੱਪਰਲੀ ਸਕ੍ਰਿਪਟ ਨੂੰ-- ark ਵਿਕਲਪ ਨਾਲ ਬਣਾਓ ਜੋ-a ਵਿਕਲਪ ਵਾਂਗ ਕੰਮ ਕਰਦਾ ਹੈ \',\' ਜ਼ਰੂਰ!ਇੱਥੇ ਸਕ੍ਰਿਪਟ ਦਾ ਇੱਕ ਅੱਪਡੇਟ ਕੀਤਾ ਸੰਸਕਰਣ ਹੈ ਜਿਸ ਵਿੱਚ ਇੱਕ \'-- ark\' ਵਿਕਲਪ ਸ਼ਾਮਲ ਹੈ ਜੋ \'-a\' ਵਿਕਲਪ ਵਾਂਗ ਹੀ ਕੰਮ ਕਰਦਾ ਹੈਃ \\n \'\' ਬੈਸ਼\\n #!/ਬਿਨ/ਬੈਸ਼\\n \'ਗੇਟਆਪਟਸ"aOR: c: d: ark" "ਆਪਟ ਕਰੋ; \\n ਕੇਸ $ਆਪਟ ਇਨ ਕਰੋ \\n a) \\n ਆਪਟ _ ਆਰਗ1 =" "$ਓਪਟਾਰਗ" "\\n; \\n ਜਾਂ \\n ਆਪਟ _ ਆਰਗ1 =" "$ਓਪਟਾਰਗ" "\\n ਆਪਟ _ ਆਰਗ2 =" "$ਓਪਟਾਰਗ" "\\n; \\n c) \\n ਆਪਟ _ ਆਰਗ1 =" "$ਓਪਟਾਰਗ" "\\n"ਆਪਟ _ ਆਰ. ਜੀ. 2 = "$ਓ. ਪੀ. ਟੀ. ਏ. ਆਰ. ਜੀ" \\n ਆਪਟ _ ਆਰ. ਜੀ. 3 = "$ਓ. ਪੀ. ਟੀ. ਏ. ਆਰ. ਜੀ" \\n; \\n) \\n ਆਪਟ _ ਆਰ. ਜੀ. 1 = "$ਓ. ਪੀ. ਟੀ. ਏ. ਆਰ. ਜੀ" \\n ਆਪਟ _ ਆਰ. ਜੀ. 2 = "$ਓ. ਪੀ. ਟੀ. ਏ. ਆਰ. ਜੀ" \\n; \\n ਆਰਕ) \\n ਆਪਟ _ ਆਰ. ਜੀ. 1 = "$ਓ. ਪੀ. ਟੀ. ਏ. ਆਰ. ਜੀ" \\n ਆਪਟ _ ਆਰ. ਜੀ. 2 = "$ਓ. ਪੀ. ਟੀ. ਏ. ਆਰ. ਜੀ" \\nਆਪਟ _ ਆਰਜੀ3 = "$ਓਪੀਟੀਏਆਰਜੀ" \\n ਆਪਟ _ ਆਰਜੀ4 = "$ਓਪੀਟੀਏਆਰਜੀ" \\n; \\n\\\\?) \\n ਗੂੰਜ "ਗਲਤੀਃ ਗਲਤ ਵਿਕਲਪ-$ਓਪੀਟੀਏਆਰਜੀ" \\n ਨਿਕਾਸ 1\\n; \\n ਈਐੱਸਏਸੀ\\ਨਡੋਨ\\ਨ\\ਨਿਫ [-z "$ਆਪਟ _ ਆਰਜੀ1"]।- z "$ਆਪਟ _ ਆਰਗ2"]।। [-z "$ਆਪਟ _ ਆਰਗ3"]।। [-z "$ਆਪਟ _ ਆਰਗ4"]; ਫਿਰ \\n ਈਕੋ ਗਲਤੀਃ ਘੱਟੋ ਘੱਟ ਇੱਕ ਵਿਕਲਪ ਆਰਗੂਮੈਂਟ ਗੁੰਮ ਹੈ "\\n ਐਗਜ਼ਿਟ 1\\nfi\\n\\necho"ਆਪਟ _ ਆਰਗ1: $ਆਪਟ _ ਆਰਗ1" "\\ਨੇਚੋ" "ਆਪਟ _ ਆਰਗ2: $ਆਪਟ _ ਆਰਗ2" "\\ਨੇਚੋ" "ਆਪਟ _ ਆਰਗ3: $ਆਪਟ _ ਆਰਗ3" "\\ਨੇਚੋ" "ਆਪਟ _ ਆਰਗ4: $ਆਪਟ _ ਆਰਗ4" "\\ਨ" "ਇਸ ਸਕ੍ਰਿਪਟ ਵਿੱਚ, \'-- ਆਰਕ\' ਵਿਕਲਪ ਹੈ।"\'-a\' ਵਿਕਲਪ ਵਾਂਗ ਹੀ ਕੰਮ ਕਰਦਾ ਹੈ। ਜਦੋਂ \'-- ark\' ਨਿਰਧਾਰਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਸਕ੍ਰਿਪਟ ਚਾਰ ਆਰਗੂਮੈਂਟ ਲੈਂਦੀ ਹੈ, ਜੋ \'ਆਪਟ _ ਆਰਗ1\', \'ਆਪਟ _ ਆਰਗ2\' ਨੂੰ ਦਿੱਤੇ ਜਾਂਦੇ ਹਨ।ਕ੍ਰਮਵਾਰ \'ਆਪਟ _ ਆਰਗ3\' ਅਤੇ \'ਆਪਟ _ ਆਰਗ4\'। \\n\\n ਇਸ ਸਕ੍ਰਿਪਟ ਦੀ ਵਰਤੋਂ ਕਰਨ ਲਈ, ਤੁਸੀਂ ਜਾਂ ਤਾਂ \'-- ark\' ਵਿਕਲਪ ਜਾਂ \'-a\' ਵਿਕਲਪ ਨਿਰਧਾਰਤ ਕਰ ਸਕਦੇ ਹੋ, ਅਤੇ ਪ੍ਰਦਾਨ ਕਰ ਸਕਦੇ ਹੋਜ਼ਰੂਰੀ ਆਰਗੂਮੈਂਟ। ਉਦਾਹਰਨ ਲਈਃ \\n "\'ruby\\n $./ਸਕ੍ਰਿਪਟ. ਸ਼-- ark ਆਰਗ1 ਆਰਗ3 ਆਰਗ4\\ਨ\' \'\\ਨ ਇਸ ਦਾ ਉਹੀ ਪ੍ਰਭਾਵ ਪਵੇਗਾ\', \'ਇਸ ਨੂੰ ਲਾਈਕ-ਏ।-- ਆਰਕ ਬਣਾਓ\'] ', 'ਸ਼ੈੱਲ ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਗੇਟਓਪਟਸ ਦੀ ਵਰਤੋਂ ਕਿਵੇਂ ਕਰਨੀ ਹੈ \n ']