ਜੰਗਾਲ ਅਤੇ ਸਿਰ ਰਹਿਤ ਕਰੋਮ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ JavaScript ਗਲਤੀਆਂ ਦਾ ਪਤਾ ਲਗਾਉਣਾ

ਹੈੱਡਲੈੱਸ ਕਰੋਮ ਨਾਲ ਜੰਗਾਲ ਵਿੱਚ JavaScript ਗਲਤੀਆਂ ਨੂੰ ਸੰਭਾਲਣਾ

ਔਨਲਾਈਨ ਆਟੋਮੇਸ਼ਨ ਜਾਂ ਟੈਸਟਿੰਗ ਨਾਲ ਨਜਿੱਠਣ ਵੇਲੇ ਡੀਬੱਗਿੰਗ ਅਤੇ ਕੋਡ ਸਥਿਰਤਾ ਦੀ ਗਰੰਟੀ ਦੇਣ ਲਈ JavaScript ਮੁੱਦਿਆਂ ਦੀ ਪਛਾਣ ਕਰਨਾ ਜ਼ਰੂਰੀ ਹੋ ਸਕਦਾ ਹੈ। ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਨੂੰ ਰਸਟ ਵਿੱਚ ਇੱਕ ਹੈੱਡਲੈੱਸ ਕ੍ਰੋਮ ਬਰਾਊਜ਼ਰ ਉਦਾਹਰਨ ਦੇ ਅੰਦਰ ਚਲਾਇਆ ਅਤੇ ਸੋਧਿਆ ਜਾ ਸਕਦਾ ਹੈ। ਕਰੇਟ ਹਾਲਾਂਕਿ, ਦਸਤਾਵੇਜ਼ਾਂ ਦੀ ਘਾਟ JavaScript ਮੁੱਦਿਆਂ ਦਾ ਪਤਾ ਲਗਾਉਣ ਲਈ ਇਸ ਕਰੇਟ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਮੁਸ਼ਕਲ ਬਣਾਉਂਦੀ ਹੈ।

ਇਹ ਲੇਖ ਦੱਸਦਾ ਹੈ ਕਿ ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਦੀਆਂ ਸਮੱਸਿਆਵਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕਿਵੇਂ ਪਛਾਣ ਕਰਨੀ ਹੈ ਜੰਗਾਲ ਵਿੱਚ crate, ਦ੍ਰਿਸ਼ਾਂ ਦੇ ਪ੍ਰਬੰਧਨ 'ਤੇ ਜ਼ੋਰ ਦੇ ਨਾਲ, ਜਿਸ ਵਿੱਚ ਇੱਕ ਸਕ੍ਰਿਪਟ ਅਸਫਲ ਹੋ ਜਾਂਦੀ ਹੈ। ਅਸੀਂ ਖਾਸ ਤੌਰ 'ਤੇ ਦੇਖਾਂਗੇ ਕਿ ਕ੍ਰੋਮ ਵਿੱਚ ਲੌਗਿੰਗ ਅਤੇ ਡੀਬਗਰ ਇਵੈਂਟਸ ਦੀ ਵਰਤੋਂ ਕਿਵੇਂ ਕਰਨੀ ਹੈ ਤਾਂ ਜੋ ਅਸਫਲ ਦਾਅਵੇ ਵਰਗੀਆਂ ਸਮੱਸਿਆਵਾਂ 'ਤੇ ਨਜ਼ਰ ਰੱਖੀ ਜਾ ਸਕੇ।

ਖਾਸ ਕਿਸਮ ਦੀਆਂ JavaScript ਅਸਫਲਤਾਵਾਂ ਦੀ ਨਿਗਰਾਨੀ ਕਰਨ ਲਈ ਰਸਟ ਵਿੱਚ ਇਵੈਂਟ ਸਰੋਤਿਆਂ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਸੈੱਟ ਕਰਨਾ ਡਿਵੈਲਪਰਾਂ ਦੁਆਰਾ ਦਰਪੇਸ਼ ਮੁਸ਼ਕਲਾਂ ਵਿੱਚੋਂ ਇੱਕ ਹੈ। ਜਿਵੇਂ ਕਿ ਅਸੀਂ ਦੇਖਾਂਗੇ, ਜਿਵੇਂ ਕਿ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਰੁਜ਼ਗਾਰ ਦੇਣ ਤੋਂ ਪਹਿਲਾਂ ਕੁਝ ਸੈੱਟਅੱਪ ਜ਼ਰੂਰੀ ਹੋ ਸਕਦਾ ਹੈ ਤੁਰੰਤ ਖੋਜਣਯੋਗ ਘਟਨਾਵਾਂ ਪੈਦਾ ਕਰਨ ਲਈ; ਇਹ ਰਸਟ ਦੀ ਇਵੈਂਟ ਹੈਂਡਲਿੰਗ ਸਮਰੱਥਾਵਾਂ ਦੀ ਡੂੰਘੀ ਸਮਝ ਦੀ ਮੰਗ ਕਰਦਾ ਹੈ।

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

ਹੁਕਮ	ਵਰਤੋਂ ਦੀ ਉਦਾਹਰਨ
	ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ crate, ਇਹ ਕਮਾਂਡ ਇੱਕ ਨਵਾਂ ਸਿਰਲੇਖ ਰਹਿਤ ਕ੍ਰੋਮ ਬਰਾਊਜ਼ਰ ਉਦਾਹਰਨ ਸ਼ੁਰੂ ਕਰਦੀ ਹੈ। ਵਿੰਡੋ ਸਾਈਜ਼ ਅਤੇ ਬ੍ਰਾਊਜ਼ਰ ਮਾਰਗ ਸਮੇਤ ਕਸਟਮ ਸਟਾਰਟਅੱਪ ਪੈਰਾਮੀਟਰ ਇਸ ਨਾਲ ਕੌਂਫਿਗਰ ਕੀਤੇ ਜਾ ਸਕਦੇ ਹਨ।
	ਇਸ ਕਮਾਂਡ ਦੀ ਮਦਦ ਨਾਲ ਲਾਂਚ ਤੋਂ ਪਹਿਲਾਂ ਬ੍ਰਾਊਜ਼ਰ ਸੈਟਿੰਗਾਂ ਨੂੰ ਕਸਟਮਾਈਜ਼ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਇਹ ਵਿੰਡੋ ਦੇ ਆਕਾਰ ਅਤੇ ਉਪਭੋਗਤਾ ਤਰਜੀਹਾਂ ਸਮੇਤ, ਕ੍ਰੋਮ ਇੰਸਟੈਂਸ ਪੈਰਾਮੀਟਰਾਂ ਦੇ ਸੰਗ੍ਰਹਿ ਦੇ ਨਿਰਮਾਣ ਵਿੱਚ ਕੰਮ ਕਰਦਾ ਹੈ।
	ਬ੍ਰਾਊਜ਼ਰ ਵਿੱਚ ਇੱਕ ਨਵੀਂ ਟੈਬ ਖੋਲ੍ਹਦਾ ਹੈ ਜਦੋਂ ਕਿ Chrome ਸੈਸ਼ਨ ਅਜੇ ਵੀ ਖੁੱਲ੍ਹਾ ਹੈ। ਇਹ ਜ਼ਰੂਰੀ ਹੈ ਜੇਕਰ ਤੁਸੀਂ ਇੱਕੋ ਸਮੇਂ ਕਈ ਪੰਨਿਆਂ 'ਤੇ ਨੈਵੀਗੇਟ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ ਜਾਂ ਇੱਕੋ ਸਮੇਂ ਕਈ JavaScript ਸਕ੍ਰਿਪਟਾਂ ਨੂੰ ਚਲਾਉਣਾ ਚਾਹੁੰਦੇ ਹੋ।
	ਕਿਰਿਆਸ਼ੀਲ ਟੈਬ ਲਈ Chrome ਡੀਬਗਰ ਨੂੰ ਚਾਲੂ ਕਰਦਾ ਹੈ, ਜਿਸ ਨਾਲ ਤੁਸੀਂ ਇਸ ਨਾਲ ਪ੍ਰੋਗਰਾਮੇਟਿਕ ਤੌਰ 'ਤੇ ਕੰਮ ਕਰ ਸਕਦੇ ਹੋ ਅਤੇ JavaScript ਵਿਰਾਮ ਜਾਂ ਸਮੱਸਿਆਵਾਂ ਵਰਗੇ ਡੀਬੱਗ ਇਵੈਂਟਾਂ ਨੂੰ ਸੁਣ ਸਕਦੇ ਹੋ।
	ਡਿਵੈਲਪਰਾਂ ਨੂੰ ਬ੍ਰਾਊਜ਼ਰ ਟੈਬ ਵਿੱਚ ਲੌਗਿੰਗ ਵਿਸ਼ੇਸ਼ਤਾ ਨੂੰ ਸਰਗਰਮ ਕਰਕੇ ਸੈਸ਼ਨ ਦੌਰਾਨ ਪੈਦਾ ਹੋਏ JavaScript ਕੰਸੋਲ ਆਉਟਪੁੱਟ, ਤਰੁੱਟੀਆਂ ਅਤੇ ਹੋਰ ਲੌਗ ਸੁਨੇਹਿਆਂ ਨੂੰ ਰਿਕਾਰਡ ਕਰਨ ਅਤੇ ਉਹਨਾਂ ਦੀ ਜਾਂਚ ਕਰਨ ਦੇ ਯੋਗ ਬਣਾਉਂਦਾ ਹੈ।
	ਇੱਕ ਇਵੈਂਟ ਲਿਸਨਰ ਨੂੰ ਜੋੜਨ ਦੇ ਨਾਲ, ਬ੍ਰਾਊਜ਼ਰ ਦਾ ਡੀਬਗਰ ਹੁਣ ਕੁਝ ਖਾਸ ਇਵੈਂਟਾਂ ਦਾ ਜਵਾਬ ਦੇ ਸਕਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ , ਅਤੇ JavaScript ਗਲਤੀਆਂ ਮਿਲਣ 'ਤੇ ਚੇਤਾਵਨੀਆਂ ਜਾਰੀ ਕਰੋ।
	Chrome ਡੀਬਗਰ ਦੁਆਰਾ ਇਹ ਪਤਾ ਲਗਾਉਣ 'ਤੇ ਕੀਤੀ ਗਈ ਇੱਕ ਖਾਸ ਕਾਰਵਾਈ ਕਿ JavaScript ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਨੂੰ ਰੋਕ ਦਿੱਤਾ ਗਿਆ ਹੈ, ਆਮ ਤੌਰ 'ਤੇ ਕਿਸੇ ਬ੍ਰੇਕਪੁਆਇੰਟ ਜਾਂ ਗਲਤੀ ਦੇ ਨਤੀਜੇ ਵਜੋਂ। ਰਨਟਾਈਮ ਦੌਰਾਨ ਅਸਫਲਤਾਵਾਂ ਨੂੰ ਹਾਸਲ ਕਰਨ ਲਈ, ਇਹ ਜ਼ਰੂਰੀ ਹੈ।
	ਮੌਜੂਦਾ ਟੈਬ ਦੇ ਸੰਦਰਭ ਵਿੱਚ ਇੱਕ JavaScript ਸਮੀਕਰਨ ਕਰਦਾ ਹੈ। ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਇੱਕ ਗਲਤੀ ਚੱਲ ਕੇ ਸ਼ੁਰੂ ਹੋ ਜਾਂਦੀ ਹੈ , ਅਤੇ ਘਟਨਾ ਸੁਣਨ ਵਾਲਾ ਇਸਨੂੰ ਰਿਕਾਰਡ ਕਰਦਾ ਹੈ।
	ਰਸਟ ਐਪਲੀਕੇਸ਼ਨ ਹੋਣ 'ਤੇ ਗੜਬੜ ਦੀ ਜਾਣਕਾਰੀ ਨੂੰ ਰਿਕਾਰਡ ਕਰਨ ਅਤੇ ਪੈਨਿਕਾਂ ਨੂੰ ਕੈਪਚਰ ਕਰਨ ਲਈ ਇੱਕ ਕਸਟਮ ਪੈਨਿਕ ਹੁੱਕ ਨੂੰ ਕੌਂਫਿਗਰ ਕਰਦਾ ਹੈ। ਇਹ JavaScript ਸਮੱਸਿਆਵਾਂ ਦੀ ਪਛਾਣ ਕਰਨ ਅਤੇ ਕਸਟਮ ਐਰਰ ਹੈਂਡਲਿੰਗ ਨੂੰ ਜੋੜਨ ਵਿੱਚ ਮਦਦਗਾਰ ਹੋ ਸਕਦਾ ਹੈ।
	ਪ੍ਰੋਗਰਾਮ ਦੇ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਨੂੰ ਪੂਰਵ-ਨਿਰਧਾਰਤ ਸਮੇਂ ਲਈ ਰੋਕਦਾ ਹੈ, JavaScript ਨੂੰ ਚੱਲਣ ਲਈ ਸਮਾਂ ਦਿੰਦਾ ਹੈ ਅਤੇ ਪ੍ਰੋਗਰਾਮ ਦੇ ਖਤਮ ਹੋਣ ਤੋਂ ਪਹਿਲਾਂ ਕਿਸੇ ਵੀ ਸੰਭਾਵੀ ਬੱਗ ਨੂੰ ਲੱਭਣ ਦਾ ਸਮਾਂ ਦਿੰਦਾ ਹੈ।

ਜੰਗਾਲ ਦੇ ਹੈੱਡਲੈੱਸ ਕ੍ਰੋਮ ਕ੍ਰੇਟ ਨਾਲ ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਗਲਤੀਆਂ ਨੂੰ ਕਿਵੇਂ ਖੋਜਿਆ ਜਾਵੇ

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

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

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

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

use headless_chrome::{protocol::cdp::types::Event, Browser, LaunchOptions};
use std::{error::Error, sync::Arc};
fn main() -> Result<(), Box<dyn Error>> {
    let browser = Browser::new(
        LaunchOptions::default_builder()
            .window_size(Some((2000, 2000)))
            .build()
            .expect("Could not find chrome-executable"),
    )?;
    let tab = browser.new_tab()?;
    tab.enable_debugger().unwrap();
    tab.enable_log().unwrap();
    let _events = tab.add_event_listener(Arc::new(move |event: &Event| {
        dbg!(event);
        if let Event::DebuggerPaused(_paused_event) = event {
            panic!("JavaScript error detected!");
        }
    }))?;
    let _remote_object = tab.evaluate("console.assert(false);", true).unwrap();
    std::thread::sleep(std::time::Duration::from_secs(1));
    Ok(())
}

use headless_chrome::{Browser, LaunchOptions};
use std::panic;
fn main() -> Result<(), Box<dyn std::error::Error>> {
    panic::set_hook(Box::new(|info| {
        println!("Panic occurred: {:?}", info);
    }));
    let browser = Browser::new(LaunchOptions::default())?;
    let tab = browser.new_tab()?;
    tab.enable_log()?;
    tab.evaluate("console.assert(false);", true)?;
    std::thread::sleep(std::time::Duration::from_secs(1));
    Ok(())
}

#[cfg(test)]
mod tests {
    use super::*;
    #[test]
    fn test_js_error_detection() {
        let browser = Browser::new(LaunchOptions::default()).unwrap();
        let tab = browser.new_tab().unwrap();
        tab.enable_log().unwrap();
        let result = tab.evaluate("console.assert(false);", true);
        assert!(result.is_err(), "Expected JavaScript error!");
    }
}

ਈਵੈਂਟ ਹੈਂਡਲਿੰਗ ਦੇ ਨਾਲ ਜੰਗਾਲ ਵਿੱਚ JavaScript ਗਲਤੀ ਖੋਜ ਨੂੰ ਵਧਾਉਣਾ

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

ਡੀਬੱਗਿੰਗ ਇਵੈਂਟਾਂ ਲਈ ਕੰਨਾਂ ਨੂੰ ਬਾਹਰ ਰੱਖਣ ਦੇ ਨਾਲ-ਨਾਲ ਰਸਟ ਨਾਲ ਗਲਤੀਆਂ ਨੂੰ ਸੁੰਦਰਤਾ ਨਾਲ ਸੰਭਾਲਣਾ ਮਹੱਤਵਪੂਰਨ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਜੰਗਾਲ ਅਤੇ ਕਿਸਮਾਂ ਨੂੰ ਡਿਵੈਲਪਰਾਂ ਦੁਆਰਾ ਬੇਸਪੋਕ ਗਲਤੀ ਕਿਸਮਾਂ ਬਣਾਉਣ ਲਈ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ। ਇਹ JavaScript ਅਸਫਲਤਾਵਾਂ ਤੋਂ ਸੁਧਾਰੀ ਗਲਤੀ ਦੇ ਪ੍ਰਸਾਰ ਅਤੇ ਰਿਕਵਰੀ ਨੂੰ ਸਮਰੱਥ ਕਰਕੇ ਤੁਹਾਡੀਆਂ ਜੰਗਾਲ ਐਪਲੀਕੇਸ਼ਨਾਂ ਨੂੰ ਹੋਰ ਮਜ਼ਬੂਤ ​​ਬਣਾਉਂਦਾ ਹੈ। ਅਸਪਸ਼ਟ ਸੁਨੇਹਿਆਂ ਦੇ ਨਾਲ ਕੰਸੋਲ ਵਿੱਚ ਲੌਗਇਨ ਕਰਕੇ ਗਲਤੀਆਂ ਨੂੰ ਵਧੇਰੇ ਤੇਜ਼ੀ ਨਾਲ ਪਛਾਣਿਆ ਜਾ ਸਕਦਾ ਹੈ, ਖਾਸ ਤੌਰ 'ਤੇ ਜਦੋਂ ਬ੍ਰਾਊਜ਼ਰ ਤੋਂ ਵਿਜ਼ੂਅਲ ਫੀਡਬੈਕ ਦੇ ਬਿਨਾਂ ਹੈੱਡਲੈੱਸ ਵਾਤਾਵਰਣ ਵਿੱਚ ਕੰਮ ਕਰਦੇ ਹੋ।

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

1. ਮੈਂ ਕਿਵੇਂ ਵਰਤ ਸਕਦਾ ਹਾਂ ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਗਲਤੀਆਂ ਲਈ ਸੁਣਨ ਲਈ ਜੰਗਾਲ ਵਿੱਚ?
2. ਰੀਅਲ-ਟਾਈਮ ਵਿੱਚ JavaScript ਸਮੱਸਿਆਵਾਂ ਦੀ ਪਛਾਣ ਕਰਨ ਲਈ, ਤੁਸੀਂ ਇਸਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ ਘਟਨਾਵਾਂ ਨੂੰ ਇਕੱਠਾ ਕਰਨ ਦਾ ਤਰੀਕਾ ਜਾਂ .
3. ਕੀ Rust ਵਿੱਚ JavaScript ਅਪਵਾਦਾਂ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਨ ਦਾ ਕੋਈ ਵਧੀਆ ਤਰੀਕਾ ਹੈ?
4. ਹਾਂ, ਤੁਸੀਂ ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰ ਸਕਦੇ ਹੋ ਕਿ ਤੁਹਾਡਾ ਪ੍ਰੋਗਰਾਮ ਰਸਟ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਅਸਫਲਤਾਵਾਂ ਨੂੰ ਸ਼ਾਨਦਾਰ ਢੰਗ ਨਾਲ ਸੰਭਾਲ ਸਕਦਾ ਹੈ JavaScript ਗਲਤੀਆਂ ਨੂੰ ਇਕੱਠਾ ਕਰਨ ਅਤੇ ਪ੍ਰਸਾਰਿਤ ਕਰਨ ਲਈ ਟਾਈਪ ਕਰੋ।
5. ਵਰਤਣ ਦਾ ਕੀ ਫਾਇਦਾ ਹੈ ਹੋਰ ਘਟਨਾਵਾਂ ਉੱਤੇ?
6. JavaScript ਅਪਵਾਦਾਂ ਬਾਰੇ ਵਧੇਰੇ ਵਿਸਥਾਰਪੂਰਵਕ ਵੇਰਵੇ ਪੇਸ਼ ਕਰਦਾ ਹੈ, ਜੋ ਰਨਟਾਈਮ ਨੁਕਸ ਦੀ ਪਛਾਣ ਅਤੇ ਨਿਸ਼ਾਨਾ ਸੰਭਾਲਣ ਦੀ ਸਹੂਲਤ ਦਿੰਦਾ ਹੈ।
7. ਮੈਂ ਵੱਖ-ਵੱਖ JavaScript ਗਲਤੀਆਂ ਲਈ ਵੱਖ-ਵੱਖ ਟੈਬਾਂ ਦੀ ਜਾਂਚ ਕਿਵੇਂ ਕਰ ਸਕਦਾ ਹਾਂ?
8. ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ , ਤੁਸੀਂ ਵੱਖ-ਵੱਖ ਵੈੱਬ ਪੰਨਿਆਂ 'ਤੇ JavaScript ਸਮੱਸਿਆਵਾਂ ਦੀ ਜਾਂਚ ਕਰਨ ਲਈ ਕਈ ਟੈਬਾਂ ਖੋਲ੍ਹ ਸਕਦੇ ਹੋ ਅਤੇ ਹਰੇਕ ਟੈਬ ਵਿੱਚ ਵੱਖਰੇ ਇਵੈਂਟ ਸਰੋਤਿਆਂ ਨੂੰ ਸ਼ਾਮਲ ਕਰ ਸਕਦੇ ਹੋ।
9. ਹੈੱਡਲੈੱਸ ਬ੍ਰਾਊਜ਼ਰ ਵਿੱਚ ਜਾਵਾਸਕ੍ਰਿਪਟ ਤਰੁੱਟੀਆਂ ਨੂੰ ਲੌਗ ਕਰਨਾ ਮਹੱਤਵਪੂਰਨ ਕਿਉਂ ਹੈ?
10. ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਗਾਰੰਟੀ ਦਿੰਦਾ ਹੈ ਕਿ JavaScript ਅਸਫਲਤਾਵਾਂ ਨੂੰ ਬਿਹਤਰ ਡੀਬੱਗਿੰਗ ਲਈ ਕੰਸੋਲ ਵਿੱਚ ਸੁਰੱਖਿਅਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਕਿਉਂਕਿ ਹੈੱਡਲੈੱਸ ਬ੍ਰਾਊਜ਼ਰਾਂ ਵਿੱਚ ਵਿਜ਼ੂਅਲ ਇੰਟਰਫੇਸ ਦੀ ਘਾਟ ਹੁੰਦੀ ਹੈ।

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

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