Back to Question Center
0

ਅਸਰਦਾਰ ਢੰਗ ਨਾਲ ਸਾਸ ਵਿੱਚ ਚੇਤਾਵਨੀਆਂ ਅਤੇ ਗਲਤੀਆਂ ਦੀ ਵਰਤੋਂ ਕਿਵੇਂ ਕਰਨੀ ਹੈ            ਸਾਸ ਵਿਚ ਪ੍ਰਭਾਵੀ ਸੰਵੇਦਨਸ਼ੀਲ ਵਿਸ਼ਿਆਂ ਵਿਚ ਚੇਤਾਵਨੀਆਂ ਅਤੇ ਗਲਤੀਆਂ ਦੀ ਵਰਤੋਂ ਕਿਵੇਂ ਕਰਨੀ ਹੈ: CSSSassFrameworksAudio & ਮਿਗਲ

1 answers:
ਅਸਰਦਾਰ ਤਰੀਕੇ ਨਾਲ ਸਾਸ ਵਿੱਚ ਚੇਤਾਵਨੀਆਂ ਅਤੇ ਗਲਤੀਆਂ ਦੀ ਵਰਤੋਂ ਕਿਵੇਂ ਕਰਨੀ ਹੈ

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

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

ਹੁਣ ਅਸੀਂ ਚੇਤਾਵਨੀਆਂ ਅਤੇ ਗਲਤੀਆਂ ਨੂੰ ਵੇਖਾਂਗੇ. ਦੋਵੇਂ ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਦੇ ਵਿਚਕਾਰ ਇਕ-ਵੇ ਸੰਚਾਰ ਸਿਸਟਮ ਬਣਾਉਂਦੇ ਹਨ (ਇਸ ਕੇਸ ਵਿੱਚ, ਸਾਸ) ਅਤੇ ਡਿਵੈਲਪਰ (ਤੁਸੀਂ). ਜੇ ਤੁਸੀਂ ਸੀ - clone watches. ਐਸ. ਵੀ. ਵਿਚ ਗਲਤੀਆਂ ਦੇ ਬਿੰਦੂ ਬਾਰੇ ਸੋਚ ਰਹੇ ਹੋ, ਤਾਂ ਯਾਦ ਰੱਖੋ ਕਿ ਤੁਸੀਂ ਪਹਿਲਾਂ ਹੀ ਜਵਾਬ ਜਾਣਦੇ ਹੋ. ਮਿਡਲ ਨੂੰ ਸੈਮੀਕੋਲਨ ਭੁੱਲ ਜਾਓ ਜਾਂ ਫੰਕਸ਼ਨ ਨੂੰ ਗ਼ਲਤ ਤਰੀਕੇ ਨਾਲ ਭੁੱਲ ਜਾਓ, Sass ਤੁਹਾਡੇ 'ਤੇ ਇੱਕ ਗਲਤੀ ਪਾਉਂਦਾ ਹੈ, ਤੁਹਾਨੂੰ ਇਹ ਸਮਝਾਇਆ ਗਿਆ ਕਿ ਤੁਸੀਂ ਕੀ ਕੀਤਾ ਹੈ ਅਤੇ ਤੁਸੀਂ ਇਸਨੂੰ ਕਿਵੇਂ ਠੀਕ ਕਰ ਸਕਦੇ ਹੋ, ਸ਼ੁਕਰਿਆ! ਇਹ ਪਤਾ ਲਗਾਉਣ ਲਈ ਕਿ ਇਹ ਕੀ ਗਲਤ ਹੋ ਗਿਆ ਹੈ, ਕੋਡ ਵਿੱਚ ਖੋਦਣ ਲਈ ਇੱਕ ਅਸਲ ਦਰਦ ਹੋਵੇਗੀ.

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

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

ਚੇਤਾਵਨੀਆਂ

ਜਿਵੇਂ ਕਿਹਾ ਗਿਆ ਹੈ, ਸਾਸ ਵਿਚ ਚੇਤਾਵਨੀਆਂ ਨੂੰ ਛਡਣ ਦੀ ਸਮਰੱਥਾ ਨਵੇਂ ਨਹੀਂ ਹੈ. @ ਵਰਨ ਡਾਇਰੈਕਟਿਵ ਰਾਹੀਂ ਕਿਸੇ ਵੀ SassScript ਸਮੀਕਰਨ ਦੇ ਸਟੈਂਡਰਡ ਆਊਟਪੁਟ ਸਟੈਂਡਰਡ ਵਿੱਚ ਸੁਨੇਹੇ ਦਿਖਾਉਣਾ ਸੰਭਵ ਹੈ.

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

ਸਾਮਟ ਸਾਸ ਵਿੱਚ ਚੇਤਾਵਨੀਆਂ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੇ ਬਹੁਤ ਸਾਰੇ ਕਾਰਨ ਹਨ ਇੱਥੇ ਇੱਕ ਜੋੜਾ ਹੈ, ਪਰ ਤੁਸੀਂ ਆਪਣੀ ਖੁਦ ਦੀ ਤਲਾਸ਼ ਕਰ ਸਕਦੇ ਹੋ:

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

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

     @ ਵਾਰਨ 'ਊਹ-ਓਹ, ਕੁਝ ਬੜਾ ਅਜੀਬ ਲੱਗਦਾ ਹੈ. ';    

ਨਿਯਮਤ CLI ਕਲਾਇਟ ਨੂੰ ਮਿਟਾਓ, ਇਹ ਚੇਤਾਵਨੀ ਹੇਠਾਂ ਦਿੱਤੇ ਆਊਟਪੁੱਟ ਨੂੰ ਛਡ ਜਾਵੇਗੀ:

     ਚੇਤਾਵਨੀ: ਊਹ - ਓ, ਕੁਝ ਅਜੀਬ ਲੱਗਦਾ ਹੈ. / ਉਪਭੋਗਤਾ / ਹਾਇਗਰਾਉਦਲ / ਜਮਾਂ-ਸ਼ੁਰੂਆਤ-ਸਾਸ / ਚੇਤਾਵਨੀ ਦੇ ਲਾਈਨ 1 ਤੇ scss    

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

     @ ਫੰਕਸ਼ਨ px-to-em ($ value, $ base-font-size: 16px) {@ ਰਿਟਰਨ ($ ਮੁੱਲ / $ ਅਧਾਰ-ਫੌਂਟ-ਆਕਾਰ) * 1em;}// ਵਰਤੋਂ foo {ਫੌਂਟ-ਸਾਈਜ਼: px-to-em (42px); // 2. 625ਮ}    

ਸਾਰੇ ਚੰਗੇ. ਹੁਣ, ਯੂਨਿਟਲ ਨੰਬਰ ਪਾਸ ਕਰਨ ਨਾਲ ਕੀ ਹੁੰਦਾ ਹੈ - ਜਿਵੇਂ ਕਿ 42 - ਫੰਕਸ਼ਨ? ਹੋ ਸਕਦਾ ਹੈ ਤੁਸੀਂ ਇਸਦਾ ਅੰਦਾਜ਼ਾ ਲਗਾ ਲਿਆ ਹੋਵੇ, ਪਰ ਕਿਉਂਕਿ ਇਹ ਬਿਲਕੁਲ ਸਪੱਸ਼ਟ ਨਹੀਂ ਹੈ ਮੈਂ ਤੁਹਾਨੂੰ ਜਵਾਬ ਦੇਵਾਂਗਾ:

     2. 625em / px ਇੱਕ ਵੈਧ CSS ਮੁੱਲ ਨਹੀਂ ਹੈ.     

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

     @ ਫੰਕਸ਼ਨ px-to-em ($ value, $ base-font-size: 16px) {@if ਯੂਨਿਟਲ ($ ਮੁੱਲ) {@ ਵਰਨਾ 'ਮੰਨ ਲਓ ਕਿ ਮੁੱਲ `# {$ value}` ਪਿਕਸਲ ਵਿੱਚ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ; ਇਸ ਨੂੰ ਬਦਲਣ ਦੀ ਕੋਸਿਸ਼ ਕੀਤੀ. ';$ ਮੁੱਲ: $ ਮਾਨ * 1 ਪੈਕਸ;}@ ਰਿਟਰਨ ($ ਮੁੱਲ / $ ਅਧਾਰ-ਫੌਂਟ-ਆਕਾਰ) * 1em;}    

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

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

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

     @ ਮਿਕਸਿਨ ਇਨਲਾਈਨ-ਬਲਾਕ {ਡਿਸਪਲੇ: ਇਨਲਾਈਨ-ਬਲਾਕ;@ ਵਾਰਨ '' ਇਨਲਾਈਨ-ਬਲਾਕ 'ਮਿਕਸਿਨ ਨੂੰ ਬਰਤਰਫ ਕੀਤਾ ਗਿਆ ਹੈ ਅਤੇ ਅਗਲਾ ਮੁੱਖ ਵਰਜਨ ਰੀਲੀਜ਼ ਕਰਕੇ ਹਟਾ ਦਿੱਤਾ ਜਾਵੇਗਾ. ';}    

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

ਫ਼ਰਕ ਦਰਮੁਕ @ ਵਾਰਨ ਅਤੇ @ ਡਿਬਗ

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

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

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

ਇਹ @ ਡੀਬਗ ਡਾਇਰੈਕਟਿਵ ਅਸਲ ਵਿੱਚ ਹੱਥ ਵਿਚ ਆ ਸਕਦੀ ਹੈ ਜਦੋਂ ਤੁਸੀਂ ਜਾਣਨਾ ਚਾਹੁੰਦੇ ਹੋ ਕਿ ਇੱਕ ਵੇਰੀਏਬਲ ਅੰਦਰ ਕੀ ਹੈ,

     @ ਡਿਬਗ $ ਅਧਾਰ-ਫੌਂਟ-ਅਕਾਰ;    

ਗਲਤੀ

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

ਤੁਸੀਂ @error ਡਾਇਰੈਕਟਿਵ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਗਲਤੀ ਸੁੱਟ ਸਕਦੇ ਹੋ. ਚੇਤਾਵਨੀਆਂ ਦੇ ਤੌਰ 'ਤੇ ਤੁਸੀਂ ਇਸ ਡਾਇਰੈਕਟਿਵ ਨੂੰ ਕੁਝ ਵੀ ਦੇ ਸਕਦੇ ਹੋ-ਜ਼ਰੂਰੀ ਨਹੀਂ ਕਿ ਇਹ ਸਟਰਿੰਗ ਹੋਵੇ, ਹਾਲਾਂਕਿ ਇਹ ਆਮ ਤੌਰ ਤੇ ਸਪਸ਼ਟ ਸੰਦਰਭ ਪ੍ਰਦਾਨ ਕਰਨ ਲਈ ਵਧੇਰੇ ਅਰਥ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ. ਦਲੀਲ (ਜੋ ਤੁਸੀਂ @ ਆਤੰਕ ਡਾਇਰੈਕਟਿਵ ਨੂੰ ਦਿੰਦੇ ਹੋ) ਸਟੈਂਡਰਡ ਆਉਟਪੁਟ ਸਟ੍ਰੀਮ ਵਿੱਚ ਛਾਪਿਆ ਜਾਵੇਗਾ, ਅਤੇ ਨਾਲ ਹੀ ਸਟੈਕ ਟਰੇਸ ਵੀ ਇਸ ਸਮੱਸਿਆ ਬਾਰੇ ਵਧੇਰੇ ਜਾਣਕਾਰੀ ਦੇਣ ਲਈ. ਕੰਪਾਈਲਏਸ਼ਨ ਪ੍ਰਕਿਰਿਆ ਇਕਦਮ ਬੰਦ ਹੋ ਜਾਵੇਗੀ.

ਆਉ ਅਸੀਂ ਸਮਾਲਟ ਅਸ਼ੁੱਧੀ ਨਾਲ ਸ਼ੁਰੂ ਕਰੀਏ:

     @ ਆਤੰਕ 'ਯੂਸੁਉਯੂ! ਨਹੀਂ. PASS ';    

ਆਉਟਪੁੱਟ ਇਸ ਤੇ ਨਿਰਭਰ ਹੋ ਸਕਦੀ ਹੈ ਕਿ ਤੁਸੀਂ ਆਪਣੇ ਸਟਾਇਲਸ਼ੀਟਾਂ ਨੂੰ ਕਿਵੇਂ ਕੰਪਾਇਲ ਕਰਦੇ ਹੋ, ਕਿਉਂਕਿ ਕੁਝ ਟੂਲ ਗਲਤੀਆਂ ਨੂੰ ਇੱਕ ਖਾਸ ਤਰੀਕੇ ਨਾਲ ਇਕੱਠਾ ਕਰਦੇ ਹਨ ਅਤੇ ਵਧਾਉਂਦੇ ਹਨ. ਸਟੈਂਡਰਡ ਸਾਸ ਰੂਬੀ ਬਾਈਨਰੀ (ਜਰਨ) ਦਾ ਇਸਤੇਮਾਲ ਕਰਨਾ, ਇਹ ਇਸ ਤਰਾਂ ਦਿਖਦਾ ਹੈ:

     ਗਲਤੀ: YOUUUUU! ਨਹੀਂ. PASS / ਉਪਭੋਗਤਾ / ਹਾਇਗਰਾਉਦਲ / ਜਮਾਂ-ਸ਼ੁਰੂਆਤ-ਸਾਸ / ਗਲਤੀ ਦੇ ਲਾਈਨ 1 ਤੇ scssਬੈਕਟਰੇਸ ਲਈ --trace ਵਰਤੋਂ     

ਟਰੇਸ ਵਿਕਲਪ ਦੇ ਨਾਲ, ਤੁਸੀਂ ਪੂਰਾ
ਸੈਸ ਖੁਦ ਤੋਂ ਸਟੈਕ ਟਰੇਸ, ਜੋ ਕਿ ਲਾਭਦਾਇਕ ਨਹੀਂ ਹੈ ਜਦ ਤੱਕ ਕਿ ਇੱਕ
ਅਸਲ ਬੱਗ ਪਹਿਲਾਂ ਕਿਤੇ ਵੀ ਪੂਰਵ ਪ੍ਰੋਸੋਸੈਸਰ ਵਿੱਚ ਹੈ. ਇਸ ਲਈ ਕਿਉਂ ਇਹ ਇੱਕ
ਮੂਲ

ਇੱਕ ਰੀਅਲ ਵਿਹਾਰਕ ਉਦਾਹਰਨ ਤੇ ਇੱਕ ਨਜ਼ਰ ਲੈਣ ਦਾ ਸਮਾਂ. ਮੈਪਸ ਵਿਚ ਡੂੰਘੇ ਮੁੱਲਾਂ ਨੂੰ ਵਰਤਣ ਵਿਚ ਸਹਾਇਤਾ ਲਈ ਇਕ ਛੋਟਾ ਜਿਹਾ ਕੰਮ ਲਿਖ ਕੇ ਚੱਲੀਏ, ਨਕਸ਼ਾ-ਡੂੰਘੀ-ਪ੍ਰਾਪਤ (.) :

     @ ਫੰਕਸ਼ਨ ਨਕਸ਼ਾ- ਡੂੰਘੀ-ਪ੍ਰਾਪਤ ($ ਨਕਸ਼ਾ, $ ਕੁੰਜੀਆਂ . ) {@ $ $ ਕੁੰਜੀ $ ਕੁੰਜੀ $ {$ map: map-get ($ ਨਕਸ਼ਾ, $ ਕੁੰਜੀ);@if (ਟਾਈਪ-ਆਫ ($ ਨਕਸ਼ਾ) == 'null') {@ ਵਾਪਰੇ $ ਨਕਸ਼ਾ;}}@ ਵਾਪਰੇ $ ਨਕਸ਼ਾ;}     

ਆਓ ਇਸ ਨੂੰ ਕਸਟਮ ਗਲਤੀ ਨਾਲ ਵਧਾਓ. ਪਰ ਪਹਿਲਾਂ, ਹੇਠਾਂ ਦਿੱਤੇ ਨਕਸ਼ੇ ਤੇ ਵਿਚਾਰ ਕਰੋ ਅਤੇ ਨਕਸ਼ਾ-ਡੂੰਘੀ-ਪ੍ਰਾਪਤ (.) ਕਾਲ ਕਰੋ:

     $ ਨਕਸ਼ਾ: ('foo': ('ਬਾਰ': ('ਬਾਜ਼': 42)));$ ਮੁੱਲ: map-deep-get ($ ਨਕਸ਼ਾ, 'foo', 'bar', 'baz', 'qux');     

ਜਿਵੇਂ ਤੁਸੀਂ ਦੇਖਿਆ ਹੋਵੇਗਾ ਕਿ ਨਕਸ਼ੇ ਵਿਚ ਬਾਜ਼ ਵਿਚ ਨੈਸਟਡ ਕੁਐਕਸ ਕੁੰਜੀ ਹੋਣ ਦੀ ਘਾਟ ਹੈ. ਦਰਅਸਲ, ਬਾਜ਼ ਦਾ ਨਕਸ਼ਾ ਨਾਲ ਵੀ ਸੰਬੰਧ ਨਹੀਂ ਹੈ; ਇਸਦੀ ਬਜਾਏ, ਇਹ ਇੱਕ ਨੰਬਰ (27 42) ਨਾਲ ਮੈਪ ਕੀਤਾ ਗਿਆ ਹੈ. ਜੇ ਅਸੀਂ ਇਸ ਕੋਡ ਨੂੰ ਲਾਗੂ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਾਂਗੇ, ਤਾਂ ਇਹ ਪੈਦਾ ਕਰੇਗਾ:

     ਗਲਤੀ: 42 'ਨਕਸ਼ੇ-ਪ੍ਰਾਪਤ' ਲਈ ਇੱਕ ਨਕਸ਼ਾ ਨਹੀਂ ਹੈ/ ਉਪਭੋਗਤਾ / ਹਾਇਗਰਾਉਦਲ / ਜਮਾਂ-ਸ਼ੁਰੂਆਤ-ਸਾਸ / ਗਲਤੀ ਦੇ ਲਾਈਨ 1 ਤੇ scss    

ਸਾਸ ਇੱਕ ਨਕਸ਼ਾ-ਪ੍ਰਾਪਤ (.) ਉੱਤੇ 42 ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦਾ ਹੈ ਅਤੇ ਇੱਕ ਗਲਤੀ ਨਿਕਲਦਾ ਹੈ ਕਿਉਂਕਿ ਇਹ ਨਹੀਂ ਕੀਤਾ ਜਾ ਸਕਦਾ. ਹਾਲਾਂਕਿ ਗਲਤੀ ਸੁਨੇਹਾ ਸਹੀ ਹੈ, ਪਰ ਇਹ ਬਹੁਤ ਮਦਦਗਾਰ ਨਹੀਂ ਹੈ. ਇਸ ਮੁੱਦੇ ਦੇ ਕਾਰਨ ਹੋਈ ਕੁੰਜੀ ਨੂੰ ਜਾਨਣ ਲਈ ਕੀ ਲਾਭਦਾਇਕ ਹੋਵੇਗਾ? ਅਸੀਂ ਇਹ ਕਰ ਸਕਦੇ ਹਾਂ!

ਅਸੀਂ ਪਹਿਲਾਂ ਹੀ ਜਾਂਚ ਕਰਦੇ ਹਾਂ ਕਿ ਕੀ $ ਨਕਸ਼ਾ ਹੈ ਨੱਲ ਮੁਢਲੇ ਰਿਟਰਨ ਕਰਨ ਲਈ, ਤਾਂ ਕਿ ਇੱਕ ਕੰਪਲੀਟੇਸ਼ਨ ਗਲਤੀ ਤੋਂ ਬਚਿਆ ਹੋਵੇ ਜੇਕਰ ਕੋਈ ਕੁੰਜੀ ਮੌਜੂਦ ਨਹੀਂ ਹੈ. ਅਸੀਂ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਇੱਕ ਦੂਜੀ ਜਾਂਚ ਕਰ ਸਕਦੇ ਹਾਂ ਕਿ ਨਕਸ਼ੇ ਅਸਲ ਵਿੱਚ ਇੱਕ ਨਕਸ਼ਾ ਹੈ, ਜਾਂ ਅਸੀਂ ਇੱਕ ਅਰਥਪੂਰਨ ਗਲਤੀ ਕੱਢਦੇ ਹਾਂ:

     @ ਫੰਕਸ਼ਨ ਨਕਸ਼ਾ- ਡੂੰਘੀ-ਪ੍ਰਾਪਤ ($ ਨਕਸ਼ਾ, $ ਕੁੰਜੀਆਂ . ) {@ $ $ ਕੁੰਜੀ $ ਕੁੰਜੀ $ {$ map: map-get ($ ਨਕਸ਼ਾ, $ ਕੁੰਜੀ);// ਜੇਕਰ `$ map` ਵਿੱਚ ਅਗਲੀ ਕੁੰਜੀ ਨਹੀਂ ਹੁੰਦੀ, ਤਾਂ` null` ਵਾਪਸ ਆਉ@if ਕਿਸਮ ਦਾ ($ ਨਕਸ਼ਾ) == 'null' {@ ਵਾਪਰੇ $ ਨਕਸ਼ਾ;}// ਜੇਕਰ `$ map` ਇੱਕ ਨਕਸ਼ਾ ਨਹੀਂ ਹੈ, ਤਾਂ ਇੱਕ ਗਲਤੀ ਸੁੱਟੋ@if ਕਿਸਮ ਦਾ ($ ਨਕਸ਼ਾ)! = 'ਮੈਪ' {@error 'ਕੁੰਜੀ' # {$ ਕੁੰਜੀ} `ਇੱਕ ਨਕਸ਼ੇ ਨਾਲ ਸੰਬੰਧਿਤ ਨਹੀਂ ਹੈ, ਪਰ ਇੱਕ # {type-of ($ map)} (` # {$ map} `). ';}}@ ਵਾਪਰੇ $ ਨਕਸ਼ਾ;}    

ਜੇ ਅਸੀਂ ਦੁਬਾਰਾ ਆਪਣੀ ਪਿਛਲੀ ਸਨਿੱਪਟ ਚਲਾਉਂਦੇ ਹਾਂ, ਤਾਂ ਇੱਥੇ ਆਉਟਪੁੱਟ ਹੈ:

     ਗਲਤੀ: ਕੁੰਜੀ `ਬਾਜ਼` ਇੱਕ ਨਕਸ਼ੇ ਨਾਲ ਸੰਬੰਧਿਤ ਨਹੀਂ ਹੈ ਪਰ ਇੱਕ ਨੰਬਰ (` 42`). / ਉਪਭੋਗਤਾ / ਹਾਇਗਰਾਉਦਲ / ਜਮਾਂ-ਸ਼ੁਰੂਆਤ-ਸਾਸ / ਗਲਤੀ ਦੇ ਲਾਈਨ 1 ਤੇ scss    

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

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

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

March 1, 2018