ਸਮੱਗਰੀ
ਇਸ ਲੇਖ ਵਿੱਚ, ਤੁਸੀਂ ਸਿੱਖੋਗੇ ਕਿ ਮੈਕਰੋ ਵਿੱਚ ਸਥਿਰ ਅਤੇ ਵੇਰੀਏਬਲ ਕੀ ਹਨ, ਉਹਨਾਂ ਦੀ ਵਰਤੋਂ ਕਿੱਥੇ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ, ਅਤੇ ਵੱਖ-ਵੱਖ ਡਾਟਾ ਕਿਸਮਾਂ ਵਿੱਚ ਮੁੱਖ ਅੰਤਰ ਕੀ ਹੈ। ਇਹ ਵੀ ਪ੍ਰਗਟ ਕੀਤਾ ਜਾਵੇਗਾ ਕਿ ਸਥਿਰਾਂਕ ਦੀ ਲੋੜ ਕਿਉਂ ਹੈ, ਜੇਕਰ ਤੁਸੀਂ ਸਿਰਫ਼ ਇੱਕ ਵੇਰੀਏਬਲ ਲਿਖ ਸਕਦੇ ਹੋ ਅਤੇ ਇਸਨੂੰ ਕਦੇ ਨਹੀਂ ਬਦਲ ਸਕਦੇ ਹੋ।
ਦੂਜੀਆਂ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾਵਾਂ ਵਾਂਗ, ਡੇਟਾ ਨੂੰ ਵੇਰੀਏਬਲ ਜਾਂ ਸਥਿਰਾਂਕ ਵਿੱਚ ਸਟੋਰ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ (ਦੋਵਾਂ ਨੂੰ ਅਕਸਰ ਡੇਟਾ ਕੰਟੇਨਰਾਂ ਵਜੋਂ ਵੀ ਜਾਣਿਆ ਜਾਂਦਾ ਹੈ)। ਇਹ ਇਹਨਾਂ ਧਾਰਨਾਵਾਂ ਵਿਚਕਾਰ ਮੁੱਖ ਅੰਤਰ ਹੈ. ਪ੍ਰੋਗ੍ਰਾਮ ਵਿੱਚ ਕੀ ਹੁੰਦਾ ਹੈ ਇਸਦੇ ਅਧਾਰ ਤੇ ਪਹਿਲਾਂ ਬਦਲ ਸਕਦਾ ਹੈ। ਬਦਲੇ ਵਿੱਚ, ਸਥਿਰਾਂਕ ਇੱਕ ਵਾਰ ਸੈੱਟ ਕੀਤੇ ਜਾਂਦੇ ਹਨ ਅਤੇ ਉਹਨਾਂ ਦੇ ਮੁੱਲ ਨੂੰ ਨਹੀਂ ਬਦਲਦੇ।
ਸਥਿਰਾਂਕ ਲਾਭਦਾਇਕ ਹੋ ਸਕਦੇ ਹਨ ਜੇਕਰ ਤੁਹਾਨੂੰ ਇੱਕੋ ਵੱਡੇ ਮੁੱਲ ਨੂੰ ਕਈ ਵਾਰ ਵਰਤਣ ਦੀ ਲੋੜ ਹੈ। ਨੰਬਰ ਦੀ ਨਕਲ ਕਰਨ ਦੀ ਬਜਾਏ, ਤੁਸੀਂ ਸਥਿਰ ਦਾ ਨਾਮ ਲਿਖ ਸਕਦੇ ਹੋ। ਉਦਾਹਰਨ ਲਈ, ਤੁਸੀਂ Pi ਨੂੰ ਸਟੋਰ ਕਰਨ ਲਈ ਸਥਿਰ "Pi" ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ, ਜੋ ਕਿ ਇੱਕ ਸਥਿਰ ਮੁੱਲ ਹੈ। ਇਹ ਬਹੁਤ ਵੱਡਾ ਹੈ, ਅਤੇ ਹਰ ਵਾਰ ਇਸਨੂੰ ਲਿਖਣਾ ਜਾਂ ਖੋਜਣਾ ਅਤੇ ਕਾਪੀ ਕਰਨਾ ਬਹੁਤ ਮੁਸ਼ਕਲ ਹੁੰਦਾ ਹੈ। ਅਤੇ ਇਸ ਲਈ, ਇਹ ਦੋ ਅੱਖਰ ਲਿਖਣ ਲਈ ਕਾਫ਼ੀ ਹੈ, ਅਤੇ ਵਾਤਾਵਰਣ ਆਪਣੇ ਆਪ ਹੀ ਲੋੜੀਂਦੇ ਨੰਬਰ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ.
ਐਕਸਲ ਉਪਭੋਗਤਾ ਨੂੰ ਵੇਰੀਏਬਲ ਘੋਸ਼ਿਤ ਕਰਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ ਜੇਕਰ ਉਸਨੂੰ ਸਮੇਂ ਸਮੇਂ ਤੇ ਉਹਨਾਂ ਵਿੱਚ ਸਟੋਰ ਕੀਤੇ ਮੁੱਲ ਨੂੰ ਬਦਲਣ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਤੁਸੀਂ sVAT_Rate ਨਾਮਕ ਇੱਕ ਵੇਰੀਏਬਲ ਸੈੱਟ ਕਰ ਸਕਦੇ ਹੋ, ਜੋ ਉਤਪਾਦ ਲਈ ਮੌਜੂਦਾ ਵੈਟ ਦਰ ਨੂੰ ਸਟੋਰ ਕਰੇਗਾ। ਜੇਕਰ ਇਹ ਬਦਲਦਾ ਹੈ, ਤਾਂ ਤੁਸੀਂ ਇਸਨੂੰ ਜਲਦੀ ਠੀਕ ਕਰ ਸਕਦੇ ਹੋ। ਇਹ ਵਿਸ਼ੇਸ਼ ਤੌਰ 'ਤੇ ਉਹਨਾਂ ਲਈ ਲਾਭਦਾਇਕ ਹੈ ਜੋ ਸੰਯੁਕਤ ਰਾਜ ਅਮਰੀਕਾ ਵਿੱਚ ਵਪਾਰ ਕਰਦੇ ਹਨ, ਜਿੱਥੇ ਕੁਝ ਵਸਤਾਂ ਵੈਟ ਦੇ ਅਧੀਨ ਨਹੀਂ ਹੋ ਸਕਦੀਆਂ (ਅਤੇ ਇਹ ਟੈਕਸ ਵੀ ਰਾਜ ਤੋਂ ਰਾਜ ਵਿੱਚ ਵੱਖਰਾ ਹੁੰਦਾ ਹੈ)।
ਡਾਟਾ ਕਿਸਮ
ਹਰੇਕ ਡੇਟਾ ਕੰਟੇਨਰ ਕਈ ਕਿਸਮਾਂ ਵਿੱਚੋਂ ਇੱਕ ਹੋ ਸਕਦਾ ਹੈ। ਇੱਥੇ ਇੱਕ ਸਾਰਣੀ ਹੈ ਜੋ ਪ੍ਰੋਸੈਸਡ ਜਾਣਕਾਰੀ ਦੀਆਂ ਮਿਆਰੀ ਕਿਸਮਾਂ ਦਾ ਵਰਣਨ ਕਰਦੀ ਹੈ। ਉਹਨਾਂ ਵਿੱਚੋਂ ਬਹੁਤ ਸਾਰੇ ਹਨ, ਅਤੇ ਇਹ ਸ਼ੁਰੂਆਤ ਵਿੱਚ ਇੱਕ ਸ਼ੁਰੂਆਤ ਕਰਨ ਵਾਲੇ ਨੂੰ ਜਾਪਦਾ ਹੈ ਕਿ ਉਹ ਇੱਕ ਦੂਜੇ ਨੂੰ ਦੁਹਰਾਉਂਦੇ ਹਨ. ਪਰ ਇਹ ਇੱਕ ਭਰਮ ਭਰਿਆ ਅਹਿਸਾਸ ਹੈ। ਇਹ ਜਾਣਨ ਲਈ ਪੜ੍ਹੋ ਕਿ ਸਹੀ ਡੇਟਾ ਕਿਸਮ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਨਾ ਇੰਨਾ ਮਹੱਤਵਪੂਰਨ ਕਿਉਂ ਹੈ।
ਅਜਿਹੀ ਡਾਟਾ ਕਿਸਮ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਸਿਫ਼ਾਰਸ਼ ਨਹੀਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਜੋ ਛੋਟੀਆਂ ਸੰਖਿਆਵਾਂ ਲਈ ਮੈਮੋਰੀ ਵਿੱਚ ਵਧੇਰੇ ਥਾਂ ਲੈਂਦਾ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਨੰਬਰ 1 ਲਈ, ਇਹ ਬਾਈਟ ਕਿਸਮ ਦੀ ਵਰਤੋਂ ਕਰਨ ਲਈ ਕਾਫੀ ਹੈ. ਇਸ ਨਾਲ ਐਗਜ਼ੀਕਿਊਟੇਬਲ ਮੋਡੀਊਲ ਦੀ ਕਾਰਗੁਜ਼ਾਰੀ 'ਤੇ ਸਕਾਰਾਤਮਕ ਪ੍ਰਭਾਵ ਪਵੇਗਾ, ਖਾਸ ਕਰਕੇ ਕਮਜ਼ੋਰ ਕੰਪਿਊਟਰਾਂ 'ਤੇ। ਪਰ ਇੱਥੇ ਬਹੁਤ ਦੂਰ ਨਾ ਜਾਣਾ ਮਹੱਤਵਪੂਰਨ ਹੈ। ਜੇਕਰ ਤੁਸੀਂ ਇੱਕ ਅਜਿਹੀ ਡਾਟਾ ਕਿਸਮ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋ ਜੋ ਬਹੁਤ ਸੰਖੇਪ ਹੈ, ਤਾਂ ਇੱਕ ਵੱਡਾ ਮੁੱਲ ਇਸ ਵਿੱਚ ਫਿੱਟ ਨਹੀਂ ਹੋ ਸਕਦਾ ਹੈ।
ਸਥਿਰਾਂਕ ਅਤੇ ਵੇਰੀਏਬਲ ਘੋਸ਼ਿਤ ਕਰਨਾ
ਪਹਿਲਾਂ ਘੋਸ਼ਣਾ ਕੀਤੇ ਬਿਨਾਂ ਇੱਕ ਡੇਟਾ ਕੰਟੇਨਰ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਸਖਤੀ ਨਾਲ ਨਿਰਾਸ਼ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਫਿਰ ਕਈ ਸਮੱਸਿਆਵਾਂ ਪੈਦਾ ਹੋ ਸਕਦੀਆਂ ਹਨ, ਜਿਸ ਤੋਂ ਬਚਣ ਲਈ ਵੇਰੀਏਬਲ ਜਾਂ ਸਥਿਰਾਂਕਾਂ ਦੀ ਗਿਣਤੀ ਦੇ ਨਾਲ ਕੋਡ ਦੀਆਂ ਕੁਝ ਛੋਟੀਆਂ ਲਾਈਨਾਂ ਲਿਖਣੀਆਂ ਜ਼ਰੂਰੀ ਹਨ।
ਇੱਕ ਵੇਰੀਏਬਲ ਘੋਸ਼ਿਤ ਕਰਨ ਲਈ, ਡਿਮ ਸਟੇਟਮੈਂਟ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਇਸ ਤਰ੍ਹਾਂ:
ਡਿਮ ਵੇਰੀਏਬਲ_ਨਾਮ ਪੂਰਨ ਅੰਕ ਵਜੋਂ
ਵੇਰੀਏਬਲ_ਨਾਮ ਵੇਰੀਏਬਲ ਦਾ ਨਾਮ ਹੈ। ਅੱਗੇ, ਡਾਟਾ ਕਿਸਮ ਨੂੰ ਦਰਸਾਉਂਦੇ ਹੋਏ, As ਆਪਰੇਟਰ ਲਿਖਿਆ ਜਾਂਦਾ ਹੈ। "Variable_Name" ਅਤੇ "Integer" ਦੀਆਂ ਸਤਰਾਂ ਦੀ ਬਜਾਏ, ਤੁਸੀਂ ਆਪਣਾ ਨਾਮ ਅਤੇ ਡਾਟਾ ਕਿਸਮ ਪਾ ਸਕਦੇ ਹੋ।
ਸਥਿਰਾਂਕ ਵੀ ਘੋਸ਼ਿਤ ਕੀਤੇ ਜਾ ਸਕਦੇ ਹਨ, ਪਰ ਤੁਹਾਨੂੰ ਪਹਿਲਾਂ ਉਹਨਾਂ ਦਾ ਮੁੱਲ ਨਿਰਧਾਰਤ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ। ਵਿਕਲਪਾਂ ਵਿੱਚੋਂ ਇੱਕ ਹੈ:
Const iMaxCount = 5000
ਨਿਰਪੱਖਤਾ ਵਿੱਚ, ਕੁਝ ਮਾਮਲਿਆਂ ਵਿੱਚ ਤੁਸੀਂ ਇੱਕ ਵੇਰੀਏਬਲ ਦੀ ਘੋਸ਼ਣਾ ਕੀਤੇ ਬਿਨਾਂ ਕਰ ਸਕਦੇ ਹੋ, ਪਰ ਇਸ ਸਥਿਤੀ ਵਿੱਚ ਉਹਨਾਂ ਨੂੰ ਸਵੈਚਲਿਤ ਰੂਪ ਵਿੱਚ ਕਿਸਮ ਨਿਰਧਾਰਤ ਕੀਤਾ ਜਾਵੇਗਾ। ਹਾਲਾਂਕਿ, ਹੇਠਾਂ ਦਿੱਤੇ ਕਾਰਨਾਂ ਕਰਕੇ ਇਸ ਦੀ ਸਿਫਾਰਸ਼ ਨਹੀਂ ਕੀਤੀ ਜਾਂਦੀ:
- ਵੇਰੀਐਂਟ ਨੂੰ ਬਹੁਤ ਜ਼ਿਆਦਾ ਹੌਲੀ-ਹੌਲੀ ਸੰਸਾਧਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਜੇਕਰ ਅਜਿਹੇ ਬਹੁਤ ਸਾਰੇ ਵੇਰੀਏਬਲ ਹਨ, ਤਾਂ ਕਮਜ਼ੋਰ ਕੰਪਿਊਟਰਾਂ 'ਤੇ ਜਾਣਕਾਰੀ ਦੀ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਕਾਫ਼ੀ ਹੌਲੀ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਅਜਿਹਾ ਲਗਦਾ ਹੈ ਕਿ ਉਹ ਸਕਿੰਟ ਫੈਸਲਾ ਕਰਨਗੇ? ਪਰ ਜੇ ਤੁਹਾਨੂੰ ਕੋਡ ਦੀਆਂ ਬਹੁਤ ਸਾਰੀਆਂ ਲਾਈਨਾਂ ਲਿਖਣੀਆਂ ਪੈਂਦੀਆਂ ਹਨ, ਅਤੇ ਫਿਰ ਇਸਨੂੰ ਕਮਜ਼ੋਰ ਕੰਪਿਊਟਰਾਂ 'ਤੇ ਵੀ ਚਲਾਉਣਾ ਹੁੰਦਾ ਹੈ (ਜੋ ਅਜੇ ਵੀ ਵੇਚੇ ਜਾਂਦੇ ਹਨ, ਕਿਉਂਕਿ ਆਧੁਨਿਕ ਆਫਿਸ ਸੂਟ ਨੂੰ ਬਹੁਤ ਜ਼ਿਆਦਾ RAM ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ), ਤੁਸੀਂ ਕੰਮ ਨੂੰ ਪੂਰੀ ਤਰ੍ਹਾਂ ਰੋਕ ਸਕਦੇ ਹੋ। ਅਜਿਹੇ ਕੇਸ ਹੁੰਦੇ ਹਨ ਜਦੋਂ ਮੈਕਰੋਜ਼ ਦੀ ਗਲਤ-ਕਲਪਨਾ ਵਾਲੀ ਲਿਖਤ ਨੇ ਸਮਾਰਟਬੁੱਕਾਂ ਨੂੰ ਜਮ੍ਹਾ ਕਰ ਦਿੱਤਾ ਜਿਨ੍ਹਾਂ ਵਿੱਚ RAM ਦੀ ਇੱਕ ਛੋਟੀ ਜਿਹੀ ਮਾਤਰਾ ਹੁੰਦੀ ਹੈ ਅਤੇ ਉਹ ਗੁੰਝਲਦਾਰ ਕੰਮ ਕਰਨ ਲਈ ਤਿਆਰ ਨਹੀਂ ਕੀਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ।
- ਨਾਵਾਂ ਵਿੱਚ ਗਲਤ ਛਾਪਣ ਦੀ ਇਜਾਜ਼ਤ ਹੈ, ਜਿਸ ਨੂੰ ਵਿਕਲਪ ਸਪੱਸ਼ਟ ਬਿਆਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਰੋਕਿਆ ਜਾ ਸਕਦਾ ਹੈ, ਜੋ ਤੁਹਾਨੂੰ ਇੱਕ ਅਣ-ਐਲਾਨੀ ਵੇਰੀਏਬਲ ਲੱਭਣ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ, ਜੇਕਰ ਕੋਈ ਲੱਭਿਆ ਜਾਂਦਾ ਹੈ। ਇਹ ਗਲਤੀਆਂ ਦਾ ਪਤਾ ਲਗਾਉਣ ਦਾ ਇੱਕ ਆਸਾਨ ਤਰੀਕਾ ਹੈ, ਕਿਉਂਕਿ ਮਾਮੂਲੀ ਟਾਈਪੋ ਕਾਰਨ ਦੁਭਾਸ਼ੀਏ ਵੇਰੀਏਬਲ ਦੀ ਪਛਾਣ ਕਰਨ ਵਿੱਚ ਅਸਮਰੱਥ ਹੋ ਜਾਂਦਾ ਹੈ। ਅਤੇ ਜੇਕਰ ਤੁਸੀਂ ਵੇਰੀਏਬਲ ਘੋਸ਼ਣਾ ਮੋਡ ਨੂੰ ਚਾਲੂ ਕਰਦੇ ਹੋ, ਤਾਂ ਦੁਭਾਸ਼ੀਏ ਤੁਹਾਨੂੰ ਮੈਕਰੋ ਚਲਾਉਣ ਦੀ ਇਜਾਜ਼ਤ ਨਹੀਂ ਦੇਵੇਗਾ ਜੇਕਰ ਡੇਟਾ ਕੰਟੇਨਰ ਮਿਲੇ ਹਨ ਜੋ ਮੋਡੀਊਲ ਦੇ ਸ਼ੁਰੂ ਵਿੱਚ ਘੋਸ਼ਿਤ ਨਹੀਂ ਕੀਤੇ ਗਏ ਸਨ।
- ਵੇਰੀਏਬਲ ਮੁੱਲਾਂ ਦੇ ਕਾਰਨ ਡੇਟਾ ਕਿਸਮ ਨਾਲ ਮੇਲ ਨਾ ਖਾਂਦੀਆਂ ਗਲਤੀਆਂ ਤੋਂ ਬਚੋ। ਆਮ ਤੌਰ 'ਤੇ, ਇੱਕ ਪੂਰਨ ਅੰਕ ਵੇਰੀਏਬਲ ਨੂੰ ਇੱਕ ਟੈਕਸਟ ਮੁੱਲ ਨਿਰਧਾਰਤ ਕਰਨਾ ਇੱਕ ਗਲਤੀ ਸੁੱਟ ਦੇਵੇਗਾ। ਹਾਂ, ਇੱਕ ਪਾਸੇ, ਇੱਕ ਆਮ ਕਿਸਮ ਨੂੰ ਬਿਨਾਂ ਘੋਸ਼ਣਾ ਦੇ ਨਿਰਧਾਰਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਪਰ ਜੇ ਉਹਨਾਂ ਨੂੰ ਪਹਿਲਾਂ ਤੋਂ ਘੋਸ਼ਿਤ ਕਰ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਬੇਤਰਤੀਬ ਗਲਤੀਆਂ ਤੋਂ ਬਚਿਆ ਜਾ ਸਕਦਾ ਹੈ।
ਇਸ ਲਈ, ਹਰ ਚੀਜ਼ ਦੇ ਬਾਵਜੂਦ, ਐਕਸਲ ਮੈਕਰੋਜ਼ ਵਿੱਚ ਸਾਰੇ ਵੇਰੀਏਬਲ ਘੋਸ਼ਿਤ ਕਰਨ ਦੀ ਜ਼ੋਰਦਾਰ ਸਿਫਾਰਸ਼ ਕੀਤੀ ਜਾਂਦੀ ਹੈ.
ਵੇਰੀਏਬਲ ਘੋਸ਼ਿਤ ਕਰਨ ਵੇਲੇ ਧਿਆਨ ਵਿੱਚ ਰੱਖਣ ਲਈ ਇੱਕ ਹੋਰ ਗੱਲ ਹੈ. ਕਿਸੇ ਵੇਰੀਏਬਲ ਨੂੰ ਘੋਸ਼ਿਤ ਕਰਨ ਵੇਲੇ ਕਿਸੇ ਵੀ ਮੁੱਲ ਨੂੰ ਨਿਰਧਾਰਤ ਨਾ ਕਰਨਾ ਸੰਭਵ ਹੈ, ਪਰ ਇਸ ਸਥਿਤੀ ਵਿੱਚ ਇਹ ਇੱਕ ਮੂਲ ਮੁੱਲ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ। ਉਦਾਹਰਣ ਲਈ:
- ਲਾਈਨਾਂ ਖਾਲੀ ਕਰ ਦਿੱਤੀਆਂ ਹਨ।
- ਨੰਬਰ 0 ਮੁੱਲ ਲੈਂਦੇ ਹਨ।
- ਬੂਲੀਅਨ ਕਿਸਮ ਦੇ ਵੇਰੀਏਬਲਾਂ ਨੂੰ ਸ਼ੁਰੂ ਵਿੱਚ ਗਲਤ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ।
- ਡਿਫਾਲਟ ਮਿਤੀ 30 ਦਸੰਬਰ, 1899 ਹੈ।
ਉਦਾਹਰਨ ਲਈ, ਜੇਕਰ ਤੁਹਾਨੂੰ ਪਹਿਲਾਂ ਕੋਈ ਮੁੱਲ ਨਿਰਧਾਰਿਤ ਨਹੀਂ ਕੀਤਾ ਗਿਆ ਸੀ ਤਾਂ ਤੁਹਾਨੂੰ ਇੱਕ ਪੂਰਨ ਅੰਕ ਵੇਰੀਏਬਲ ਨੂੰ ਮੁੱਲ 0 ਨਿਰਧਾਰਤ ਕਰਨ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ। ਉਸ ਕੋਲ ਪਹਿਲਾਂ ਹੀ ਇਹ ਨੰਬਰ ਹੈ।
ਵਿਕਲਪ ਸਪੱਸ਼ਟ ਬਿਆਨ
ਇਹ ਕਥਨ ਤੁਹਾਨੂੰ VBA ਕੋਡ ਵਿੱਚ ਵਰਤੇ ਗਏ ਸਾਰੇ ਵੇਰੀਏਬਲਾਂ ਦਾ ਐਲਾਨ ਕਰਨ ਅਤੇ ਕੋਡ ਦੇ ਚੱਲਣ ਤੋਂ ਪਹਿਲਾਂ ਕਿਸੇ ਵੀ ਅਣਐਲਾਨੀ ਕੰਟੇਨਰਾਂ ਦੀ ਮੌਜੂਦਗੀ ਦਾ ਪਤਾ ਲਗਾਉਣ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ। ਇਸ ਵਿਸ਼ੇਸ਼ਤਾ ਦੀ ਵਰਤੋਂ ਕਰਨ ਲਈ, ਮੈਕਰੋ ਕੋਡ ਦੇ ਬਿਲਕੁਲ ਸਿਖਰ 'ਤੇ ਸਿਰਫ਼ ਵਿਕਲਪ ਸਪੱਸ਼ਟ ਕੋਡ ਦੀ ਇੱਕ ਲਾਈਨ ਲਿਖੋ।
ਜੇਕਰ ਤੁਹਾਨੂੰ ਹਰ ਵਾਰ ਆਪਣੇ ਕੋਡ ਵਿੱਚ ਇਸ ਕਥਨ ਨੂੰ ਸ਼ਾਮਲ ਕਰਨ ਦੀ ਲੋੜ ਹੈ, ਤਾਂ ਤੁਸੀਂ VBA ਸੰਪਾਦਕ ਵਿੱਚ ਇੱਕ ਵਿਸ਼ੇਸ਼ ਸੈਟਿੰਗ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਅਜਿਹਾ ਕਰ ਸਕਦੇ ਹੋ। ਇਸ ਵਿਕਲਪ ਨੂੰ ਸਮਰੱਥ ਕਰਨ ਲਈ, ਤੁਹਾਨੂੰ ਇਹ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ:
- ਮਾਰਗ ਦੇ ਨਾਲ ਵਿਕਾਸ ਵਾਤਾਵਰਣ 'ਤੇ ਜਾਓ - ਟੂਲਜ਼ > ਵਿਕਲਪ।
- ਇਸ ਤੋਂ ਬਾਅਦ ਖੁੱਲਣ ਵਾਲੀ ਵਿੰਡੋ ਵਿੱਚ, ਐਡੀਟਰ ਟੈਬ ਨੂੰ ਖੋਲ੍ਹੋ।
- ਅਤੇ ਅੰਤ ਵਿੱਚ, ਲੋੜੀਂਦੇ ਵੇਰੀਏਬਲ ਘੋਸ਼ਣਾ ਆਈਟਮ ਦੇ ਅੱਗੇ ਵਾਲੇ ਬਾਕਸ ਨੂੰ ਚੁਣੋ।
ਇਹਨਾਂ ਕਦਮਾਂ ਨੂੰ ਪੂਰਾ ਕਰਨ ਤੋਂ ਬਾਅਦ, "ਠੀਕ ਹੈ" ਬਟਨ 'ਤੇ ਕਲਿੱਕ ਕਰੋ।
ਬੱਸ, ਹੁਣ ਜਦੋਂ ਹਰੇਕ ਨਵਾਂ ਮੈਕਰੋ ਲਿਖ ਰਹੇ ਹੋ, ਤਾਂ ਇਹ ਲਾਈਨ ਆਪਣੇ ਆਪ ਕੋਡ ਦੇ ਸਿਖਰ 'ਤੇ ਪਾਈ ਜਾਵੇਗੀ।
ਸਥਿਰਾਂਕ ਅਤੇ ਵੇਰੀਏਬਲਾਂ ਦਾ ਘੇਰਾ
ਹਰੇਕ ਵੇਰੀਏਬਲ ਜਾਂ ਸਥਿਰਾਂਕ ਦਾ ਸਿਰਫ਼ ਇੱਕ ਸੀਮਤ ਸਕੋਪ ਹੁੰਦਾ ਹੈ। ਇਹ ਨਿਰਭਰ ਕਰਦਾ ਹੈ ਕਿ ਤੁਸੀਂ ਇਸਨੂੰ ਕਿੱਥੇ ਘੋਸ਼ਿਤ ਕਰਦੇ ਹੋ।
ਮੰਨ ਲਓ ਸਾਡੇ ਕੋਲ ਇੱਕ ਫੰਕਸ਼ਨ ਹੈ ਕੁੱਲ_ਲਾਗਤ(), ਅਤੇ ਇਹ ਵੇਰੀਏਬਲ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ sVAT_Rate. ਮੋਡੀਊਲ ਵਿੱਚ ਸਥਿਤੀ 'ਤੇ ਨਿਰਭਰ ਕਰਦਿਆਂ, ਇਸਦਾ ਇੱਕ ਵੱਖਰਾ ਸਕੋਪ ਹੋਵੇਗਾ:
| ਵਿਕਲਪ ਸਪਸ਼ਟ ਮੱਧਮ sVAT_ਰੇਟ ਸਿੰਗਲ ਵਜੋਂ ਫੰਕਸ਼ਨ Total_Cost() ਡਬਲ ਵਜੋਂ . . . ਅੰਤ ਫੰਕਸ਼ਨ | ਜੇਕਰ ਇੱਕ ਵੇਰੀਏਬਲ ਨੂੰ ਇੱਕ ਮੋਡੀਊਲ ਦੇ ਸਿਖਰ 'ਤੇ ਘੋਸ਼ਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਇਹ ਉਸ ਮੋਡੀਊਲ ਵਿੱਚ ਫੈਲਦਾ ਹੈ। ਭਾਵ, ਇਸ ਨੂੰ ਹਰ ਵਿਧੀ ਦੁਆਰਾ ਪੜ੍ਹਿਆ ਜਾ ਸਕਦਾ ਹੈ. ਇਸ ਤੋਂ ਇਲਾਵਾ, ਜੇਕਰ ਕਿਸੇ ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਨੇ ਵੇਰੀਏਬਲ ਦੇ ਮੁੱਲ ਨੂੰ ਬਦਲ ਦਿੱਤਾ ਹੈ, ਤਾਂ ਅਗਲਾ ਇਸ ਸਹੀ ਕੀਤੇ ਮੁੱਲ ਨੂੰ ਵੀ ਪੜ੍ਹੇਗਾ। ਪਰ ਦੂਜੇ ਮੋਡੀਊਲ ਵਿੱਚ ਇਹ ਵੇਰੀਏਬਲ ਅਜੇ ਵੀ ਪੜ੍ਹਿਆ ਨਹੀਂ ਜਾਵੇਗਾ। |
| ਵਿਕਲਪ ਸਪਸ਼ਟ ਫੰਕਸ਼ਨ Total_Cost() ਡਬਲ ਵਜੋਂ ਮੱਧਮ sVAT_ਰੇਟ ਸਿੰਗਲ ਵਜੋਂ . . . ਅੰਤ ਫੰਕਸ਼ਨ | ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਵੇਰੀਏਬਲ ਨੂੰ ਪ੍ਰਕਿਰਿਆ ਦੇ ਅੰਦਰ ਘੋਸ਼ਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਦੁਭਾਸ਼ੀਏ ਇੱਕ ਗਲਤੀ ਸੁੱਟ ਦੇਵੇਗਾ ਜੇਕਰ ਇਹ ਕਿਸੇ ਹੋਰ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਵਰਤੀ ਜਾਂਦੀ ਹੈ। |
ਜੇਕਰ ਤੁਸੀਂ ਚਾਹੁੰਦੇ ਹੋ ਕਿ ਵੇਰੀਏਬਲ ਨੂੰ ਹੋਰ ਮੋਡੀਊਲਾਂ ਦੁਆਰਾ ਪੜ੍ਹਿਆ ਜਾਵੇ, ਤਾਂ ਤੁਹਾਨੂੰ ਡਿਮ ਕੀਵਰਡ ਦੀ ਬਜਾਏ ਪਬਲਿਕ ਕੀਵਰਡ ਦੀ ਵਰਤੋਂ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ। ਇਸੇ ਤਰ੍ਹਾਂ, ਤੁਸੀਂ ਪਬਲਿਕ ਸਟੇਟਮੈਂਟ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਵੇਰੀਏਬਲ ਦੇ ਦਾਇਰੇ ਨੂੰ ਸਿਰਫ਼ ਮੌਜੂਦਾ ਮੋਡੀਊਲ ਤੱਕ ਸੀਮਤ ਕਰ ਸਕਦੇ ਹੋ, ਜੋ ਕਿ ਸ਼ਬਦ ਦੀ ਬਜਾਏ ਡਿਮ ਲਿਖਿਆ ਗਿਆ ਹੈ।
ਤੁਸੀਂ ਕੰਸਟੈਂਟਸ ਦਾ ਸਕੋਪ ਵੀ ਇਸੇ ਤਰ੍ਹਾਂ ਸੈੱਟ ਕਰ ਸਕਦੇ ਹੋ, ਪਰ ਇੱਥੇ ਕੀਵਰਡ Const ਆਪਰੇਟਰ ਦੇ ਨਾਲ ਲਿਖਿਆ ਗਿਆ ਹੈ।
ਇੱਥੇ ਇੱਕ ਚੰਗੀ ਉਦਾਹਰਨ ਦੇ ਨਾਲ ਇੱਕ ਸਾਰਣੀ ਹੈ ਕਿ ਇਹ ਸਥਿਰਾਂਕਾਂ ਅਤੇ ਵੇਰੀਏਬਲਾਂ ਨਾਲ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ।
| ਵਿਕਲਪ ਸਪਸ਼ਟ ਸਰਵਜਨਕ sVAT_Rate as ਸਿੰਗਲ ਪਬਲਿਕ ਕੰਸਟ iMax_Count = 5000 | ਇਸ ਉਦਾਹਰਨ ਵਿੱਚ, ਤੁਸੀਂ ਦੇਖ ਸਕਦੇ ਹੋ ਕਿ ਇੱਕ ਵੇਰੀਏਬਲ ਘੋਸ਼ਿਤ ਕਰਨ ਲਈ ਪਬਲਿਕ ਕੀਵਰਡ ਦੀ ਵਰਤੋਂ ਕਿਵੇਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਅਤੇ ਇੱਕ ਜਨਤਕ ਸਥਿਰਤਾ ਘੋਸ਼ਿਤ ਕਰਨ ਲਈ ਤੁਹਾਨੂੰ ਵਿਜ਼ੂਅਲ ਬੇਸਿਕ ਐਡੀਟਰ ਵਿੱਚ ਕੀ ਲਿਖਣ ਦੀ ਲੋੜ ਹੈ। ਇਹਨਾਂ ਮੁੱਲਾਂ ਵਾਲੇ ਕੰਟੇਨਰਾਂ ਦਾ ਦਾਇਰਾ ਸਾਰੇ ਮੋਡੀਊਲਾਂ 'ਤੇ ਲਾਗੂ ਹੁੰਦਾ ਹੈ। |
| ਵਿਕਲਪ ਸਪਸ਼ਟ ਪ੍ਰਾਈਵੇਟ sVAT_Rate as ਸਿੰਗਲ ਪ੍ਰਾਈਵੇਟ ਕੰਸਟ iMax_Count = 5000 | ਇੱਥੇ, ਵੇਰੀਏਬਲ ਅਤੇ ਸਥਿਰਾਂਕ ਨੂੰ ਪ੍ਰਾਈਵੇਟ ਕੀਵਰਡ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਘੋਸ਼ਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਉਹਨਾਂ ਨੂੰ ਸਿਰਫ ਮੌਜੂਦਾ ਮੋਡੀਊਲ ਵਿੱਚ ਦੇਖਿਆ ਜਾ ਸਕਦਾ ਹੈ, ਅਤੇ ਦੂਜੇ ਮੋਡੀਊਲ ਵਿੱਚ ਪ੍ਰਕਿਰਿਆਵਾਂ ਉਹਨਾਂ ਦੀ ਵਰਤੋਂ ਨਹੀਂ ਕਰ ਸਕਦੀਆਂ। |
ਸਥਿਰਾਂਕ ਅਤੇ ਵੇਰੀਏਬਲਾਂ ਦੀ ਲੋੜ ਕਿਉਂ ਹੈ
ਸਥਿਰਾਂਕ ਅਤੇ ਵੇਰੀਏਬਲ ਦੀ ਵਰਤੋਂ ਤੁਹਾਨੂੰ ਕੋਡ ਦੀ ਸਮਝ ਦੀ ਡਿਗਰੀ ਨੂੰ ਵਧਾਉਣ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ। ਅਤੇ ਜੇਕਰ ਆਮ ਤੌਰ 'ਤੇ ਸ਼ੁਰੂਆਤ ਕਰਨ ਵਾਲਿਆਂ ਕੋਲ ਇਸ ਬਾਰੇ ਸਵਾਲ ਨਹੀਂ ਹੁੰਦੇ ਕਿ ਵੇਰੀਏਬਲਾਂ ਦੀ ਲੋੜ ਕਿਉਂ ਹੈ, ਤਾਂ ਸਥਿਰਾਂਕ ਦੀ ਲੋੜ ਬਾਰੇ ਬਹੁਤ ਸਾਰੀਆਂ ਅਸਪਸ਼ਟਤਾਵਾਂ ਹਨ। ਅਤੇ ਇਹ ਸਵਾਲ, ਪਹਿਲੀ ਨਜ਼ਰ 'ਤੇ, ਕਾਫ਼ੀ ਲਾਜ਼ੀਕਲ ਲੱਗਦਾ ਹੈ. ਆਖਰਕਾਰ, ਤੁਸੀਂ ਇੱਕ ਵੇਰੀਏਬਲ ਨੂੰ ਇੱਕ ਵਾਰ ਘੋਸ਼ਿਤ ਕਰ ਸਕਦੇ ਹੋ ਅਤੇ ਇਸਨੂੰ ਦੁਬਾਰਾ ਕਦੇ ਨਹੀਂ ਬਦਲ ਸਕਦੇ ਹੋ।
ਜਵਾਬ ਉਸੇ ਸਮਤਲ ਵਿੱਚ ਕਿਤੇ ਨਿਕਲਦਾ ਹੈ ਜਿਵੇਂ ਕਿ ਡੇਟਾ ਕਿਸਮਾਂ ਦੀ ਵਰਤੋਂ ਦੇ ਸਬੰਧ ਵਿੱਚ ਜੋ ਮੈਮੋਰੀ ਵਿੱਚ ਇੱਕ ਵੱਡੀ ਥਾਂ ਰੱਖਦਾ ਹੈ। ਜੇਕਰ ਅਸੀਂ ਬਹੁਤ ਸਾਰੇ ਵੇਰੀਏਬਲਾਂ ਨਾਲ ਕੰਮ ਕਰ ਰਹੇ ਹਾਂ, ਤਾਂ ਅਸੀਂ ਗਲਤੀ ਨਾਲ ਮੌਜੂਦਾ ਕੰਟੇਨਰ ਨੂੰ ਬਦਲ ਸਕਦੇ ਹਾਂ। ਜੇਕਰ ਉਪਭੋਗਤਾ ਇਹ ਤਜਵੀਜ਼ ਕਰਦਾ ਹੈ ਕਿ ਇੱਕ ਨਿਸ਼ਚਿਤ ਮੁੱਲ ਕਦੇ ਨਹੀਂ ਬਦਲੇਗਾ, ਤਾਂ ਵਾਤਾਵਰਣ ਆਪਣੇ ਆਪ ਇਸ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰੇਗਾ।
ਇਹ ਵਿਸ਼ੇਸ਼ ਤੌਰ 'ਤੇ ਮਹੱਤਵਪੂਰਨ ਹੁੰਦਾ ਹੈ ਜਦੋਂ ਮੈਕਰੋ ਨੂੰ ਕਈ ਪ੍ਰੋਗਰਾਮਰਾਂ ਦੁਆਰਾ ਲਿਖਿਆ ਜਾਂਦਾ ਹੈ। ਇੱਕ ਨੂੰ ਪਤਾ ਹੋ ਸਕਦਾ ਹੈ ਕਿ ਕੁਝ ਵੇਰੀਏਬਲ ਨੂੰ ਨਹੀਂ ਬਦਲਣਾ ਚਾਹੀਦਾ ਹੈ। ਅਤੇ ਦੂਜਾ ਨਹੀਂ ਹੈ। ਜੇਕਰ ਤੁਸੀਂ Const ਆਪਰੇਟਰ ਨੂੰ ਨਿਸ਼ਚਿਤ ਕਰਦੇ ਹੋ, ਤਾਂ ਕਿਸੇ ਹੋਰ ਡਿਵੈਲਪਰ ਨੂੰ ਪਤਾ ਲੱਗ ਜਾਵੇਗਾ ਕਿ ਇਹ ਮੁੱਲ ਨਹੀਂ ਬਦਲਦਾ ਹੈ।
ਜਾਂ, ਜੇਕਰ ਇੱਕ ਨਾਮ ਦੇ ਨਾਲ ਇੱਕ ਸਥਿਰ ਹੈ, ਅਤੇ ਵੇਰੀਏਬਲ ਦਾ ਇੱਕ ਵੱਖਰਾ, ਪਰ ਸਮਾਨ ਨਾਮ ਹੈ। ਡਿਵੈਲਪਰ ਬਸ ਉਹਨਾਂ ਨੂੰ ਉਲਝਾ ਸਕਦਾ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਇੱਕ ਵੇਰੀਏਬਲ ਜਿਸ ਨੂੰ ਬਦਲਣ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ, ਨੂੰ ਵੇਰੀਏਬਲ 11 ਕਿਹਾ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਇੱਕ ਹੋਰ ਜਿਸਨੂੰ ਸੰਪਾਦਿਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ, ਨੂੰ ਵੇਰੀਏਬਲ1 ਕਿਹਾ ਜਾਂਦਾ ਹੈ। ਇੱਕ ਵਿਅਕਤੀ ਆਪਣੇ ਆਪ, ਕੋਡ ਲਿਖਣ ਵੇਲੇ, ਗਲਤੀ ਨਾਲ ਇੱਕ ਵਾਧੂ ਯੂਨਿਟ ਨੂੰ ਛੱਡ ਸਕਦਾ ਹੈ ਅਤੇ ਇਸਨੂੰ ਨੋਟਿਸ ਨਹੀਂ ਕਰ ਸਕਦਾ ਹੈ। ਨਤੀਜੇ ਵਜੋਂ, ਮੁੱਲਾਂ ਲਈ ਕੰਟੇਨਰ ਬਦਲਿਆ ਜਾਵੇਗਾ, ਜਿਸ ਨੂੰ ਛੂਹਿਆ ਨਹੀਂ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ।
ਜਾਂ ਡਿਵੈਲਪਰ ਖੁਦ ਭੁੱਲ ਸਕਦਾ ਹੈ ਕਿ ਉਹ ਕਿਹੜੇ ਵੇਰੀਏਬਲ ਨੂੰ ਛੂਹ ਸਕਦਾ ਹੈ ਅਤੇ ਕਿਨ੍ਹਾਂ ਨੂੰ ਨਹੀਂ ਕਰ ਸਕਦਾ। ਇਹ ਅਕਸਰ ਉਦੋਂ ਵਾਪਰਦਾ ਹੈ ਜਦੋਂ ਕੋਡ ਨੂੰ ਕਈ ਹਫ਼ਤਿਆਂ ਲਈ ਲਿਖਿਆ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਇਸਦਾ ਆਕਾਰ ਵੱਡਾ ਹੋ ਜਾਂਦਾ ਹੈ। ਇਸ ਸਮੇਂ ਦੌਰਾਨ, ਇਹ ਭੁੱਲਣਾ ਬਹੁਤ ਆਸਾਨ ਹੈ ਕਿ ਇਸ ਜਾਂ ਉਸ ਵੇਰੀਏਬਲ ਦਾ ਕੀ ਅਰਥ ਹੈ।
ਹਾਂ, ਤੁਸੀਂ ਇਸ ਸਥਿਤੀ ਵਿੱਚ ਟਿੱਪਣੀਆਂ ਦੇ ਨਾਲ ਕਰ ਸਕਦੇ ਹੋ, ਪਰ ਕੀ Const ਸ਼ਬਦ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਨਾ ਆਸਾਨ ਨਹੀਂ ਹੈ?
ਸਿੱਟੇ
ਵੇਰੀਏਬਲ ਮੈਕਰੋ ਪ੍ਰੋਗਰਾਮਿੰਗ ਦਾ ਇੱਕ ਜ਼ਰੂਰੀ ਹਿੱਸਾ ਹਨ, ਜੋ ਤੁਹਾਨੂੰ ਗੁੰਝਲਦਾਰ ਕਾਰਵਾਈਆਂ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦੇ ਹਨ, ਗਣਨਾ ਤੋਂ ਲੈ ਕੇ ਉਪਭੋਗਤਾ ਨੂੰ ਕੁਝ ਘਟਨਾਵਾਂ ਬਾਰੇ ਸੂਚਿਤ ਕਰਨ ਜਾਂ ਸਪ੍ਰੈਡਸ਼ੀਟ ਦੇ ਸੈੱਲਾਂ ਵਿੱਚ ਖਾਸ ਮੁੱਲਾਂ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਨ ਤੱਕ।
ਸਥਿਰਾਂਕ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾਣੀ ਚਾਹੀਦੀ ਹੈ ਜੇਕਰ ਵਿਕਾਸਕਾਰ ਇਹ ਯਕੀਨੀ ਤੌਰ 'ਤੇ ਜਾਣਦਾ ਹੈ ਕਿ ਭਵਿੱਖ ਵਿੱਚ ਇਹਨਾਂ ਕੰਟੇਨਰਾਂ ਦੀ ਸਮੱਗਰੀ ਨਹੀਂ ਬਦਲੇਗੀ। ਇਸਦੀ ਬਜਾਏ ਵੇਰੀਏਬਲ ਦੀ ਵਰਤੋਂ ਨਾ ਕਰਨ ਦੀ ਸਿਫਾਰਸ਼ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਕਿਉਂਕਿ ਗਲਤੀ ਨਾਲ ਗਲਤੀ ਹੋ ਸਕਦੀ ਹੈ।