ਅਸੀਂ JavaScript ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ Zabbix ਵਿੱਚ ਵਿਹਾਰਕ ਸਮੱਸਿਆਵਾਂ ਨੂੰ ਹੱਲ ਕਰਦੇ ਹਾਂ

ਟਿਖੋਨ ਉਸਕੋਵ, Zabbix ਏਕੀਕਰਣ ਟੀਮ ਇੰਜੀਨੀਅਰ

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

Zabbix ਲਈ JavaScript

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

Zabbix 4.4 ਵਿੱਚ, JavaScript ਵਿੱਚ ਪ੍ਰੀ-ਪ੍ਰੋਸੈਸਿੰਗ ਦੇ ਇੱਕ ਤਰਕਪੂਰਨ ਨਿਰੰਤਰਤਾ ਦੇ ਰੂਪ ਵਿੱਚ, ਇੱਕ ਨਵੀਂ ਸੂਚਨਾ ਵਿਧੀ ਪ੍ਰਗਟ ਹੋਈ ਹੈ - ਵੈਬਹੁੱਕ, ਜਿਸਦੀ ਵਰਤੋਂ ਤੀਜੀ-ਧਿਰ ਦੀਆਂ ਐਪਲੀਕੇਸ਼ਨਾਂ ਨਾਲ ਜ਼ੈਬਿਕਸ ਸੂਚਨਾਵਾਂ ਨੂੰ ਆਸਾਨੀ ਨਾਲ ਜੋੜਨ ਲਈ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ।

JavaScript ਅਤੇ Duktapes

JavaScript ਅਤੇ Duktape ਨੂੰ ਕਿਉਂ ਚੁਣਿਆ ਗਿਆ ਸੀ? ਭਾਸ਼ਾਵਾਂ ਅਤੇ ਇੰਜਣਾਂ ਲਈ ਕਈ ਵਿਕਲਪਾਂ 'ਤੇ ਵਿਚਾਰ ਕੀਤਾ ਗਿਆ ਸੀ:

• ਲੁਆ - ਲੁਆ 5.1
• ਲੁਆ – ਲੁਆਜੀਤ
• Javascript - Duktape
• ਜਾਵਾਸਕ੍ਰਿਪਟ - ਜੈਰੀ ਸਕ੍ਰਿਪਟ
• ਏਮਬੈੱਡ ਪਾਈਥਨ
• ਏਮਬੈਡਡ ਪਰਲ

ਮੁੱਖ ਚੋਣ ਮਾਪਦੰਡ ਪ੍ਰਚਲਿਤ ਸਨ, ਉਤਪਾਦ ਵਿੱਚ ਇੰਜਣ ਦੇ ਏਕੀਕਰਨ ਦੀ ਸੌਖ, ਘੱਟ ਸਰੋਤ ਦੀ ਖਪਤ ਅਤੇ ਇੰਜਣ ਦੀ ਸਮੁੱਚੀ ਕਾਰਗੁਜ਼ਾਰੀ, ਅਤੇ ਨਿਗਰਾਨੀ ਵਿੱਚ ਇਸ ਭਾਸ਼ਾ ਵਿੱਚ ਕੋਡ ਨੂੰ ਪੇਸ਼ ਕਰਨ ਦੀ ਸੁਰੱਖਿਆ। ਸੂਚਕਾਂ ਦੇ ਸੁਮੇਲ ਦੇ ਆਧਾਰ 'ਤੇ, JavaScript ਨੇ Duktape ਇੰਜਣ 'ਤੇ ਜਿੱਤ ਪ੍ਰਾਪਤ ਕੀਤੀ।

ਚੋਣ ਮਾਪਦੰਡ ਅਤੇ ਪ੍ਰਦਰਸ਼ਨ ਟੈਸਟਿੰਗ

ਡਕਟੇਪ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ:

- ਮਿਆਰੀ ECMAScript E5/E5.1
- ਡਕਟੇਪ ਲਈ ਜ਼ੈਬਿਕਸ ਮੋਡੀਊਲ:

• Zabbix.log() - ਤੁਹਾਨੂੰ Zabbix ਸਰਵਰ ਲੌਗ ਵਿੱਚ ਸਿੱਧੇ ਵੇਰਵੇ ਦੇ ਵੱਖ-ਵੱਖ ਪੱਧਰਾਂ ਦੇ ਨਾਲ ਸੁਨੇਹੇ ਲਿਖਣ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ, ਜੋ ਕਿ ਗਲਤੀਆਂ ਨੂੰ ਸੰਬਧਿਤ ਕਰਨਾ ਸੰਭਵ ਬਣਾਉਂਦਾ ਹੈ, ਉਦਾਹਰਨ ਲਈ, ਇੱਕ ਵੈਬਹੁੱਕ ਵਿੱਚ, ਸਰਵਰ ਸਥਿਤੀ ਨਾਲ।
• CurlHttpRequest() - ਤੁਹਾਨੂੰ ਨੈੱਟਵਰਕ ਲਈ HTTP ਬੇਨਤੀਆਂ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ, ਜਿਸ 'ਤੇ ਵੈਬਹੁੱਕ ਦੀ ਵਰਤੋਂ ਆਧਾਰਿਤ ਹੈ।
• atob() ਅਤੇ btoa() - ਤੁਹਾਨੂੰ ਬੇਸ 64 ਫਾਰਮੈਟ ਵਿੱਚ ਸਟਰਿੰਗਾਂ ਨੂੰ ਏਨਕੋਡ ਅਤੇ ਡੀਕੋਡ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ।

ਨੋਟ. Duktape ACME ਮਾਪਦੰਡਾਂ ਦੀ ਪਾਲਣਾ ਕਰਦਾ ਹੈ। ਜ਼ੈਬਿਕਸ ਸਕ੍ਰਿਪਟ ਦੇ 2015 ਸੰਸਕਰਣ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ। ਬਾਅਦ ਦੀਆਂ ਤਬਦੀਲੀਆਂ ਮਾਮੂਲੀ ਹਨ, ਇਸਲਈ ਉਹਨਾਂ ਨੂੰ ਨਜ਼ਰਅੰਦਾਜ਼ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।.

ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਮੈਜਿਕ

JavaScript ਦਾ ਸਾਰਾ ਜਾਦੂ ਗਤੀਸ਼ੀਲ ਟਾਈਪਿੰਗ ਅਤੇ ਟਾਈਪ ਕਾਸਟਿੰਗ ਵਿੱਚ ਹੈ: ਸਟ੍ਰਿੰਗ, ਸੰਖਿਆਤਮਕ, ਅਤੇ ਬੁਲੀਅਨ।

ਇਸਦਾ ਮਤਲਬ ਇਹ ਹੈ ਕਿ ਇਹ ਪਹਿਲਾਂ ਤੋਂ ਘੋਸ਼ਿਤ ਕਰਨਾ ਜ਼ਰੂਰੀ ਨਹੀਂ ਹੈ ਕਿ ਕਿਸ ਕਿਸਮ ਦੇ ਵੇਰੀਏਬਲ ਨੂੰ ਇੱਕ ਮੁੱਲ ਵਾਪਸ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ.

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

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

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

ਉਦਾਹਰਨ ਲਈ, ਜੇਕਰ ਵਸਤੂ ਲਈ 'obj' ਵਿਧੀ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤਾ ਗਿਆ ਹੈ ਟੂਸਟ੍ਰਿੰਗ,

`var obj = { toString() { return "200" }}` 

ਢੰਗ ਟੂਸਟ੍ਰਿੰਗ ਬਿਲਕੁਲ ਇੱਕ ਸਤਰ ਵਾਪਸ ਕਰਦਾ ਹੈ, ਅਤੇ ਜਦੋਂ ਇੱਕ ਨੰਬਰ ਦੇ ਨਾਲ ਇੱਕ ਸਤਰ ਜੋੜਦੇ ਹਾਂ, ਤਾਂ ਸਾਨੂੰ ਇੱਕ ਚਿਪਕਾਈ ਸਤਰ ਮਿਲਦੀ ਹੈ:

`obj + 1 // '2001'` 

`obj + 'a' // ‘200a'`

ਪਰ ਜੇ ਤੁਸੀਂ ਦੁਬਾਰਾ ਲਿਖਦੇ ਹੋ ਟੂਸਟ੍ਰਿੰਗ, ਤਾਂ ਕਿ ਵਿਧੀ ਇੱਕ ਸੰਖਿਆ ਵਾਪਸ ਕਰੇ, ਜਦੋਂ ਵਸਤੂ ਨੂੰ ਜੋੜਿਆ ਜਾਂਦਾ ਹੈ, ਇੱਕ ਸੰਖਿਆਤਮਕ ਰੂਪਾਂਤਰਣ ਦੇ ਨਾਲ ਇੱਕ ਗਣਿਤਿਕ ਕਾਰਵਾਈ ਕੀਤੀ ਜਾਵੇਗੀ ਅਤੇ ਗਣਿਤਿਕ ਜੋੜ ਦਾ ਨਤੀਜਾ ਪ੍ਰਾਪਤ ਕੀਤਾ ਜਾਵੇਗਾ।

`var obj = { toString() { return 200 }}` 

`obj + 1 // '2001'`

ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਜੇਕਰ ਅਸੀਂ ਇੱਕ ਸਟ੍ਰਿੰਗ ਨਾਲ ਜੋੜਦੇ ਹਾਂ, ਤਾਂ ਇੱਕ ਸਟ੍ਰਿੰਗ ਰੂਪਾਂਤਰਨ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਸਾਨੂੰ ਇੱਕ ਗੂੰਦ ਵਾਲੀ ਸਤਰ ਮਿਲਦੀ ਹੈ।

`obj + 'a' // ‘200a'`

ਇਹ ਨਵੇਂ JavaScript ਉਪਭੋਗਤਾਵਾਂ ਦੁਆਰਾ ਵੱਡੀ ਗਿਣਤੀ ਵਿੱਚ ਗਲਤੀਆਂ ਦਾ ਕਾਰਨ ਹੈ.

ਢੰਗ ਟੂਸਟ੍ਰਿੰਗ ਤੁਸੀਂ ਇੱਕ ਫੰਕਸ਼ਨ ਲਿਖ ਸਕਦੇ ਹੋ ਜੋ ਵਸਤੂ ਦੇ ਮੌਜੂਦਾ ਮੁੱਲ ਨੂੰ 1 ਦੁਆਰਾ ਵਧਾਏਗਾ।

ਸਕ੍ਰਿਪਟ ਦਾ ਐਗਜ਼ੀਕਿਊਸ਼ਨ, ਬਸ਼ਰਤੇ ਕਿ ਵੇਰੀਏਬਲ 3 ਦੇ ਬਰਾਬਰ ਹੋਵੇ, ਅਤੇ ਇਹ 4 ਦੇ ਬਰਾਬਰ ਵੀ ਹੋਵੇ।

ਜਦੋਂ ਇੱਕ ਕਾਸਟ (==) ਨਾਲ ਤੁਲਨਾ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਤਾਂ ਵਿਧੀ ਨੂੰ ਹਰ ਵਾਰ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ ਟੂਸਟ੍ਰਿੰਗ ਮੁੱਲ ਵਾਧੇ ਫੰਕਸ਼ਨ ਦੇ ਨਾਲ. ਇਸ ਅਨੁਸਾਰ, ਹਰੇਕ ਅਗਲੀ ਤੁਲਨਾ ਦੇ ਨਾਲ, ਮੁੱਲ ਵਧਦਾ ਹੈ। ਗੈਰ-ਕਾਸਟ ਤੁਲਨਾ (===) ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇਸ ਤੋਂ ਬਚਿਆ ਜਾ ਸਕਦਾ ਹੈ।

ਕਿਸਮ ਕਾਸਟਿੰਗ ਤੋਂ ਬਿਨਾਂ ਤੁਲਨਾ

ਨੋਟ. ਕਾਸਟ ਤੁਲਨਾ ਦੀ ਬੇਲੋੜੀ ਵਰਤੋਂ ਨਾ ਕਰੋ.

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

ਵੈਬਹੁੱਕ ਮੀਡੀਆ

2019 ਦੇ ਅਖੀਰ ਵਿੱਚ ਅਤੇ 2020 ਦੇ ਸ਼ੁਰੂ ਵਿੱਚ, ਜ਼ੈਬਿਕਸ ਏਕੀਕਰਣ ਟੀਮ ਸਰਗਰਮੀ ਨਾਲ ਵੈਬਹੁੱਕ ਅਤੇ ਆਊਟ-ਆਫ-ਦ-ਬਾਕਸ ਏਕੀਕਰਣਾਂ ਨੂੰ ਵਿਕਸਤ ਕਰ ਰਹੀ ਹੈ ਜੋ ਜ਼ੈਬਿਕਸ ਡਿਸਟ੍ਰੀਬਿਊਸ਼ਨ ਦੇ ਨਾਲ ਆਉਂਦੇ ਹਨ।

• ਵਿਵਾਦ
• Jira
• ਜੀਰਾ ਸਰਵਿਸ ਡੈਸਕ
• ਸਭ ਤੋਂ ਜ਼ਰੂਰੀ
• ਮਾਈਕਰੋਸਾਫਟ ਟੀਮਾਂ
• ਓਪਸਜੀਨੀ
• ਹੋਰ
• ਪੇਜਰਡਿਊਟੀ
• ਪੁਸ਼ੋਵਰ
• ਰੇਮਾਈਨ
• ਸਰਵਿਸਨੂ
• SINGL4
• ਢਿੱਲ
• ਤਾਰ
• ਜ਼ਮਾਦ
• ਜ਼ੈਂਡੇਸਕ

ਨਾਲ ਲਿੰਕ ਦਸਤਾਵੇਜ਼

ਪੂਰਵ ਪ੍ਰਕਿਰਿਆ

• JavaScript ਵਿੱਚ ਪ੍ਰੀ-ਪ੍ਰੋਸੈਸਿੰਗ ਦੇ ਆਗਮਨ ਨੇ ਜ਼ਿਆਦਾਤਰ ਬਾਹਰੀ ਸਕ੍ਰਿਪਟਾਂ ਨੂੰ ਛੱਡਣਾ ਸੰਭਵ ਬਣਾਇਆ, ਅਤੇ ਵਰਤਮਾਨ ਵਿੱਚ ਜ਼ੈਬਿਕਸ ਵਿੱਚ ਤੁਸੀਂ ਕੋਈ ਵੀ ਮੁੱਲ ਪ੍ਰਾਪਤ ਕਰ ਸਕਦੇ ਹੋ ਅਤੇ ਇਸਨੂੰ ਇੱਕ ਬਿਲਕੁਲ ਵੱਖਰੇ ਮੁੱਲ ਵਿੱਚ ਬਦਲ ਸਕਦੇ ਹੋ।
• ਜ਼ੈਬਿਕਸ ਵਿੱਚ ਪ੍ਰੀਪ੍ਰੋਸੈਸਿੰਗ ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਕੋਡ ਦੁਆਰਾ ਲਾਗੂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਜੋ, ਜਦੋਂ ਬਾਈਟਕੋਡ ਵਿੱਚ ਕੰਪਾਇਲ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਇੱਕ ਫੰਕਸ਼ਨ ਵਿੱਚ ਬਦਲਿਆ ਜਾਂਦਾ ਹੈ ਜੋ ਇੱਕ ਪੈਰਾਮੀਟਰ ਦੇ ਤੌਰ ਤੇ ਇੱਕ ਸਿੰਗਲ ਮੁੱਲ ਲੈਂਦਾ ਹੈ ਮੁੱਲ ਇੱਕ ਸਤਰ ਦੇ ਰੂਪ ਵਿੱਚ (ਇੱਕ ਸਤਰ ਵਿੱਚ ਇੱਕ ਅੰਕ ਅਤੇ ਇੱਕ ਨੰਬਰ ਦੋਵੇਂ ਸ਼ਾਮਲ ਹੋ ਸਕਦੇ ਹਨ)।
• ਕਿਉਂਕਿ ਆਉਟਪੁੱਟ ਇੱਕ ਫੰਕਸ਼ਨ ਹੈ, ਸਕ੍ਰਿਪਟ ਦੇ ਅੰਤ ਵਿੱਚ ਲੋੜੀਂਦਾ ਹੈ ਵਾਪਸੀ.
• ਕੋਡ ਵਿੱਚ ਕਸਟਮ ਮੈਕਰੋ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਸੰਭਵ ਹੈ।
• ਸੰਸਾਧਨਾਂ ਨੂੰ ਨਾ ਸਿਰਫ਼ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਪੱਧਰ 'ਤੇ ਸੀਮਿਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ, ਸਗੋਂ ਪ੍ਰੋਗਰਾਮੇਟਿਕ ਤੌਰ 'ਤੇ ਵੀ। ਪ੍ਰੀ-ਪ੍ਰੋਸੈਸਿੰਗ ਪੜਾਅ ਨੂੰ ਅਧਿਕਤਮ 10 ਮੈਗਾਬਾਈਟ RAM ਅਤੇ 10 ਸਕਿੰਟਾਂ ਦੀ ਰਨ ਟਾਈਮ ਸੀਮਾ ਨਿਰਧਾਰਤ ਕੀਤੀ ਗਈ ਹੈ।

ਨੋਟ. 10 ਸਕਿੰਟਾਂ ਦਾ ਸਮਾਂ ਸਮਾਪਤ ਮੁੱਲ ਬਹੁਤ ਜ਼ਿਆਦਾ ਹੈ, ਕਿਉਂਕਿ "ਭਾਰੀ" ਪ੍ਰੀਪ੍ਰੋਸੈਸਿੰਗ ਦ੍ਰਿਸ਼ ਦੇ ਅਨੁਸਾਰ 1 ਸਕਿੰਟ ਵਿੱਚ ਹਜ਼ਾਰਾਂ ਸ਼ਰਤੀਆ ਡੇਟਾ ਆਈਟਮਾਂ ਨੂੰ ਇਕੱਠਾ ਕਰਨਾ ਜ਼ੈਬਿਕਸ ਨੂੰ ਹੌਲੀ ਕਰ ਸਕਦਾ ਹੈ। ਇਸਲਈ, ਅਖੌਤੀ ਸ਼ੈਡੋ ਡੇਟਾ ਐਲੀਮੈਂਟਸ (ਡੰਮੀ ਆਈਟਮਾਂ) ਦੁਆਰਾ ਪੂਰੀ ਤਰ੍ਹਾਂ ਦੀਆਂ JavaScript ਸਕ੍ਰਿਪਟਾਂ ਨੂੰ ਚਲਾਉਣ ਲਈ ਪ੍ਰੀ-ਪ੍ਰੋਸੈਸਿੰਗ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਸਿਫਾਰਸ਼ ਨਹੀਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਜੋ ਸਿਰਫ ਪ੍ਰੀ-ਪ੍ਰੋਸੈਸਿੰਗ ਕਰਨ ਲਈ ਚਲਾਈਆਂ ਜਾਂਦੀਆਂ ਹਨ।.

ਤੁਸੀਂ ਪ੍ਰੀ-ਪ੍ਰੋਸੈਸਿੰਗ ਟੈਸਟ ਦੁਆਰਾ ਜਾਂ ਉਪਯੋਗਤਾ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਆਪਣੇ ਕੋਡ ਦੀ ਜਾਂਚ ਕਰ ਸਕਦੇ ਹੋ zabbix_js:

`zabbix_js -s *script-file -p *input-param* [-l log-level] [-t timeout]`

`zabbix_js -s script-file -i input-file [-l log-level] [-t timeout]`

`zabbix_js -h`

`zabbix_js -V`

ਵਿਹਾਰਕ ਕੰਮ

ਉਦੇਸ਼ 1

ਗਣਨਾ ਕੀਤੀ ਆਈਟਮ ਨੂੰ ਪ੍ਰੀ-ਪ੍ਰੋਸੈਸਿੰਗ ਨਾਲ ਬਦਲੋ।

ਸ਼ਰਤ: ਸੈਲਸੀਅਸ ਵਿੱਚ ਸਟੋਰ ਕਰਨ ਲਈ ਸੈਂਸਰ ਤੋਂ ਫਾਰਨਹੀਟ ਵਿੱਚ ਤਾਪਮਾਨ ਪ੍ਰਾਪਤ ਕਰੋ।

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

ਸਮੱਸਿਆਵਾਂ:

• ਡੇਟਾ ਦੇ ਤੱਤਾਂ ਨੂੰ ਡੁਪਲੀਕੇਟ ਕਰਨਾ ਅਤੇ ਡੇਟਾਬੇਸ ਵਿੱਚ ਸਾਰੇ ਮੁੱਲਾਂ ਨੂੰ ਸਟੋਰ ਕਰਨਾ ਜ਼ਰੂਰੀ ਹੈ.
• ਤੁਹਾਨੂੰ "ਮਾਪਿਆਂ" ਡੇਟਾ ਆਈਟਮ ਲਈ ਅੰਤਰਾਲਾਂ 'ਤੇ ਸਹਿਮਤ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ ਜਿਸਦੀ ਗਣਨਾ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਅਤੇ ਫਾਰਮੂਲੇ ਵਿੱਚ ਵਰਤੀ ਜਾਂਦੀ ਹੈ, ਅਤੇ ਗਣਨਾ ਕੀਤੀ ਡੇਟਾ ਆਈਟਮ ਲਈ। ਨਹੀਂ ਤਾਂ, ਗਣਨਾ ਕੀਤੀ ਆਈਟਮ ਅਸਮਰਥਿਤ ਸਥਿਤੀ ਵਿੱਚ ਜਾ ਸਕਦੀ ਹੈ ਜਾਂ ਪਿਛਲੇ ਮੁੱਲ ਦੀ ਗਣਨਾ ਕਰ ਸਕਦੀ ਹੈ, ਜੋ ਨਿਗਰਾਨੀ ਦੇ ਨਤੀਜਿਆਂ ਦੀ ਭਰੋਸੇਯੋਗਤਾ ਨੂੰ ਪ੍ਰਭਾਵਤ ਕਰੇਗੀ।

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

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

ਇਸ ਸਮੱਸਿਆ ਵਿੱਚ, ਅਨੁਕੂਲ ਹੱਲ ਇੱਕ-ਲਾਈਨ JavaScript ਪ੍ਰੀਪ੍ਰੋਸੈਸਿੰਗ ਹੈ ਜੋ ਡਿਗਰੀ ਫਾਰਨਹੀਟ ਨੂੰ ਡਿਗਰੀ ਸੈਲਸੀਅਸ ਵਿੱਚ ਬਦਲਦਾ ਹੈ:

`return (value - 32) * 5 / 9;`

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

`return (parseInt(value) + parseInt("{$EXAMPLE.MACRO}"));`

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

`return (value + "{$EXAMPLE.MACRO}");`

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

ਟਾਸਕ 2

ਸਰਟੀਫਿਕੇਟ ਦੇ ਅੰਤ ਤੱਕ ਸਮਾਂ ਸਕਿੰਟਾਂ ਵਿੱਚ ਪ੍ਰਾਪਤ ਕਰੋ।

ਸ਼ਰਤ: ਇੱਕ ਸੇਵਾ "ਫਰਵਰੀ 12 12:33:56 2022 GMT" ਫਾਰਮੈਟ ਵਿੱਚ ਇੱਕ ਸਰਟੀਫਿਕੇਟ ਦੀ ਮਿਆਦ ਪੁੱਗਣ ਦੀ ਮਿਤੀ ਜਾਰੀ ਕਰਦੀ ਹੈ।

ECMAScript5 ਵਿੱਚ date.parse() ISO 8601 ਫਾਰਮੈਟ (YYYY-MM-DDTHH:mm:ss.sssZ) ਵਿੱਚ ਇੱਕ ਮਿਤੀ ਸਵੀਕਾਰ ਕਰਦਾ ਹੈ। ਇਸ ਨੂੰ MMM DD YYYY HH:mm:ss ZZ ਫਾਰਮੈਟ ਵਿੱਚ ਇੱਕ ਸਟ੍ਰਿੰਗ ਲਗਾਉਣਾ ਜ਼ਰੂਰੀ ਹੈ

ਸਮੱਸਿਆ: ਮਹੀਨੇ ਦੇ ਮੁੱਲ ਨੂੰ ਪਾਠ ਦੇ ਰੂਪ ਵਿੱਚ ਦਰਸਾਇਆ ਗਿਆ ਹੈ, ਇੱਕ ਸੰਖਿਆ ਦੇ ਰੂਪ ਵਿੱਚ ਨਹੀਂ। ਇਸ ਫਾਰਮੈਟ ਵਿੱਚ ਡੇਟਾ ਡਕਟੇਪ ਦੁਆਰਾ ਸਵੀਕਾਰ ਨਹੀਂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

ਹੱਲ ਉਦਾਹਰਨ:

• ਸਭ ਤੋਂ ਪਹਿਲਾਂ, ਇੱਕ ਵੇਰੀਏਬਲ ਘੋਸ਼ਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਜੋ ਇੱਕ ਮੁੱਲ ਲੈਂਦਾ ਹੈ (ਪੂਰੀ ਸਕ੍ਰਿਪਟ ਉਹਨਾਂ ਵੇਰੀਏਬਲਾਂ ਦੀ ਘੋਸ਼ਣਾ ਹੁੰਦੀ ਹੈ ਜੋ ਕਾਮਿਆਂ ਦੁਆਰਾ ਵੱਖ ਕੀਤੇ ਸੂਚੀਬੱਧ ਹੁੰਦੇ ਹਨ)।

• ਪਹਿਲੀ ਲਾਈਨ ਵਿੱਚ ਸਾਨੂੰ ਪੈਰਾਮੀਟਰ ਵਿੱਚ ਮਿਤੀ ਮਿਲਦੀ ਹੈ ਮੁੱਲ ਅਤੇ ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇਸਨੂੰ ਖਾਲੀ ਥਾਂਵਾਂ ਨਾਲ ਵੱਖ ਕਰੋ ਵੰਡ. ਇਸ ਤਰ੍ਹਾਂ, ਸਾਨੂੰ ਇੱਕ ਐਰੇ ਮਿਲਦਾ ਹੈ, ਜਿੱਥੇ ਐਰੇ ਦਾ ਹਰੇਕ ਐਲੀਮੈਂਟ, ਇੰਡੈਕਸ 0 ਤੋਂ ਸ਼ੁਰੂ ਹੁੰਦਾ ਹੈ, ਇੱਕ ਸਪੇਸ ਤੋਂ ਪਹਿਲਾਂ ਅਤੇ ਬਾਅਦ ਵਿੱਚ ਇੱਕ ਮਿਤੀ ਤੱਤ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ। ਵੰਡ (0) - ਮਹੀਨਾ, ਵੰਡ (1) - ਗਿਣਤੀ, ਵੰਡ (2) - ਸਮੇਂ ਦੇ ਨਾਲ ਇੱਕ ਸਤਰ, ਆਦਿ। ਉਸ ਤੋਂ ਬਾਅਦ, ਮਿਤੀ ਦੇ ਹਰੇਕ ਤੱਤ ਨੂੰ ਐਰੇ ਵਿੱਚ ਸੂਚਕਾਂਕ ਦੁਆਰਾ ਐਕਸੈਸ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।

`var split = value.split(' '),`

• ਹਰ ਮਹੀਨਾ (ਕਾਲਕ੍ਰਮਿਕ ਕ੍ਰਮ ਵਿੱਚ) ਐਰੇ ਵਿੱਚ ਇਸਦੀ ਸਥਿਤੀ ਦੇ ਸੂਚਕਾਂਕ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ (0 ਤੋਂ 11 ਤੱਕ)। ਇੱਕ ਟੈਕਸਟ ਮੁੱਲ ਨੂੰ ਇੱਕ ਸੰਖਿਆਤਮਕ ਮੁੱਲ ਵਿੱਚ ਬਦਲਣ ਲਈ, ਇੱਕ ਨੂੰ ਮਹੀਨੇ ਦੇ ਸੂਚਕਾਂਕ ਵਿੱਚ ਜੋੜਿਆ ਜਾਂਦਾ ਹੈ (ਕਿਉਂਕਿ ਮਹੀਨਿਆਂ ਦੀ ਗਿਣਤੀ 1 ਤੋਂ ਸ਼ੁਰੂ ਹੁੰਦੀ ਹੈ)। ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਇੱਕ ਦੇ ਜੋੜ ਦੇ ਨਾਲ ਸਮੀਕਰਨ ਨੂੰ ਬਰੈਕਟਾਂ ਵਿੱਚ ਲਿਆ ਜਾਂਦਾ ਹੈ, ਕਿਉਂਕਿ ਨਹੀਂ ਤਾਂ ਇੱਕ ਸਟ੍ਰਿੰਗ ਪ੍ਰਾਪਤ ਕੀਤੀ ਜਾਏਗੀ, ਨੰਬਰ ਨਹੀਂ। ਅੰਤ ਵਿੱਚ ਅਸੀਂ ਕਰਦੇ ਹਾਂ ਟੁਕੜਾ() - ਸਿਰਫ਼ ਦੋ ਅੱਖਰ ਛੱਡਣ ਲਈ ਸਿਰੇ ਤੋਂ ਐਰੇ ਨੂੰ ਕੱਟੋ (ਜੋ ਕਿ ਦੋ-ਅੰਕੀ ਨੰਬਰ ਵਾਲੇ ਮਹੀਨਿਆਂ ਲਈ ਮਹੱਤਵਪੂਰਨ ਹੈ)।

`MONTHS_LIST = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'],`

`month_index = ('0' + (MONTHS_LIST.indexOf(split[0]) + 1)).slice(-2),`

• ਅਸੀਂ ਢੁਕਵੇਂ ਕ੍ਰਮ ਵਿੱਚ ਸਤਰ ਦੇ ਆਮ ਜੋੜ ਦੁਆਰਾ ਪ੍ਰਾਪਤ ਕੀਤੇ ਮੁੱਲਾਂ ਤੋਂ ISO ਫਾਰਮੈਟ ਵਿੱਚ ਇੱਕ ਸਤਰ ਬਣਾਉਂਦੇ ਹਾਂ।

`ISOdate = split[3] + '-' + month_index + '-' + split[1] + 'T' + split[2],`

ਨਤੀਜੇ ਵਾਲੇ ਫਾਰਮੈਟ ਵਿੱਚ ਡੇਟਾ 1970 ਤੋਂ ਭਵਿੱਖ ਵਿੱਚ ਕਿਸੇ ਬਿੰਦੂ ਤੱਕ ਸਕਿੰਟਾਂ ਦੀ ਸੰਖਿਆ ਹੈ। ਟਰਿਗਰਸ ਵਿੱਚ ਪ੍ਰਾਪਤ ਕੀਤੇ ਫਾਰਮੈਟ ਵਿੱਚ ਡੇਟਾ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਲਗਭਗ ਅਸੰਭਵ ਹੈ, ਕਿਉਂਕਿ ਜ਼ੈਬਿਕਸ ਤੁਹਾਨੂੰ ਸਿਰਫ ਮੈਕਰੋ ਨਾਲ ਕੰਮ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ {ਤਾਰੀਖ਼} и {ਸਮਾਂ}, ਜੋ ਉਪਭੋਗਤਾ-ਅਨੁਕੂਲ ਫਾਰਮੈਟ ਵਿੱਚ ਮਿਤੀ ਅਤੇ ਸਮਾਂ ਵਾਪਸ ਕਰਦੇ ਹਨ।

• ਅਸੀਂ ਫਿਰ ਯੂਨਿਕਸ ਟਾਈਮਸਟੈਂਪ ਫਾਰਮੈਟ ਵਿੱਚ JavaScript ਵਿੱਚ ਮੌਜੂਦਾ ਮਿਤੀ ਪ੍ਰਾਪਤ ਕਰ ਸਕਦੇ ਹਾਂ ਅਤੇ ਪ੍ਰਮਾਣ-ਪੱਤਰ ਦੀ ਮਿਆਦ ਪੁੱਗਣ ਤੱਕ ਮਿਲੀਸਕਿੰਟ ਦੀ ਸੰਖਿਆ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਨਤੀਜੇ ਵਜੋਂ ਸਰਟੀਫਿਕੇਟ ਦੀ ਮਿਆਦ ਪੁੱਗਣ ਦੀ ਮਿਤੀ ਤੋਂ ਇਸਨੂੰ ਘਟਾ ਸਕਦੇ ਹਾਂ।

`now = Date.now();`

• ਜ਼ੈਬਿਕਸ ਵਿੱਚ ਸਕਿੰਟ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਅਸੀਂ ਪ੍ਰਾਪਤ ਮੁੱਲ ਨੂੰ ਇੱਕ ਹਜ਼ਾਰ ਨਾਲ ਵੰਡਦੇ ਹਾਂ।

`return parseInt((Date.parse(ISOdate) - now) / 1000);`

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

ਨੋਟ. ਵਰਤੋਂ ਵੱਲ ਧਿਆਨ ਦਿਓ parseInt() ਫੰਕਸ਼ਨ ਵਿੱਚ ਵਾਪਸੀਮਿਲੀਸਕਿੰਟ ਦੀ ਵੰਡ ਦੇ ਨਤੀਜੇ ਵਜੋਂ ਅੰਸ਼ਕ ਸੰਖਿਆ ਨੂੰ ਪੂਰਨ ਅੰਕ ਵਿੱਚ ਤਬਦੀਲ ਕਰਨ ਲਈ। ਤੁਸੀਂ ਵੀ ਵਰਤ ਸਕਦੇ ਹੋ ਪਾਰਸਫਲੋਟ() ਅਤੇ ਫਰੈਕਸ਼ਨਲ ਡਾਟਾ ਸਟੋਰ ਕਰੋ.

ਰਿਪੋਰਟ ਦੇਖੋ

ਸਰੋਤ: www.habr.com