Powershell ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਗ੍ਰੇਡ 7-9 ਵਿੱਚ ਸਕੂਲੀ ਬੱਚਿਆਂ ਲਈ ਇੱਕ ਸਧਾਰਨ ਟੈਲੀਗ੍ਰਾਮ ਬੋਟ ਲਈ ਟੈਂਪਲੇਟ

ਇੱਕ ਦੋਸਤ ਨਾਲ ਗੱਲਬਾਤ ਦੌਰਾਨ, ਮੈਨੂੰ ਅਚਾਨਕ ਪਤਾ ਲੱਗਾ ਕਿ ਉਨ੍ਹਾਂ ਦੇ ਸਕੂਲ ਵਿੱਚ ਗ੍ਰੇਡ 8-10 ਦੇ ਬੱਚਿਆਂ ਨੂੰ ਪ੍ਰੋਗਰਾਮਿੰਗ ਬਿਲਕੁਲ ਨਹੀਂ ਸਿਖਾਈ ਜਾਂਦੀ ਹੈ। ਸ਼ਬਦ, ਐਕਸਲ ਅਤੇ ਸਭ ਕੁਝ. ਕੋਈ ਲੋਗੋ ਨਹੀਂ, ਪਾਸਕਲ ਵੀ ਨਹੀਂ, ਐਕਸਲ ਲਈ VBA ਵੀ ਨਹੀਂ।

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

ਅੰਤ ਵਿੱਚ, ਮੈਂ ਕੁਝ ਘੰਟੇ ਬਿਤਾਉਣ ਅਤੇ "ਸਕੂਲ ਦੇ ਬੱਚਿਆਂ ਲਈ ਇੱਕ ਸਧਾਰਨ ਬੋਟ ਕਿਵੇਂ ਬਣਾਉਣਾ ਹੈ" ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਬਣਾਉਣ ਦਾ ਫੈਸਲਾ ਕੀਤਾ।

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

TLDR: ਵਿਆਕਰਨਿਕ ਅਤੇ ਤੱਥਾਂ ਦੀਆਂ ਗਲਤੀਆਂ ਵਾਲਾ ਇੱਕ ਹੋਰ ਬੋਰਿੰਗ ਲੇਖ, ਪੜ੍ਹਨ ਲਈ ਕੁਝ ਨਹੀਂ, ਕੋਈ ਹਾਸੋਹੀਣਾ ਨਹੀਂ, ਕੋਈ ਤਸਵੀਰਾਂ ਨਹੀਂ।

ਲੇਖ ਵਿੱਚ ਕੁਝ ਵੀ ਨਵਾਂ ਨਹੀਂ ਹੈ, ਪਹਿਲਾਂ ਲਿਖੀ ਗਈ ਲਗਭਗ ਹਰ ਚੀਜ਼ ਪਹਿਲਾਂ ਹੀ ਹੈਬਰੇ 'ਤੇ ਹੈ, ਉਦਾਹਰਣ ਲਈ ਲੇਖਾਂ ਵਿੱਚ ਹਦਾਇਤਾਂ: ਟੈਲੀਗ੍ਰਾਮ ਵਿੱਚ ਬੋਟ ਕਿਵੇਂ ਬਣਾਉਣੇ ਹਨ и ਸਿਸਟਮ ਪ੍ਰਸ਼ਾਸਕ ਲਈ ਟੈਲੀਗ੍ਰਾਮ ਬੋਟ.
ਇਸ ਤੋਂ ਇਲਾਵਾ, ਲੇਖ ਜਾਣਬੁੱਝ ਕੇ ਬੇਲੋੜਾ ਹੈ ਤਾਂ ਜੋ ਹਰ ਵਾਰ ਵਿਦਿਅਕ ਸਾਹਿਤ ਦਾ ਹਵਾਲਾ ਨਾ ਦਿੱਤਾ ਜਾਵੇ। ਟੈਕਸਟ ਵਿੱਚ ਗੈਂਗ 4, ਪਾਵਰਸ਼ੇਲ ਡੀਪ ਡਾਈਵਜ਼ ਜਾਂ, ਕਹੋ, AWS ਵੈਲ-ਆਰਕੀਟੈਕਟਡ ਫਰੇਮਵਰਕ ਦੇ 5 ਥੰਮਾਂ ਦਾ ਕੋਈ ਹਵਾਲਾ ਨਹੀਂ ਹੈ।

ਇੱਕ ਪ੍ਰਸਤਾਵਨਾ ਦੀ ਬਜਾਏ, ਤੁਸੀਂ ਛੱਡ ਸਕਦੇ ਹੋ

ਛੱਡਣ ਲਈ ਬੇਝਿਜਕ ਮਹਿਸੂਸ ਕਰੋ2006 ਵਿੱਚ, ਮਾਈਕ੍ਰੋਸਾਫਟ ਨੇ ਉਸ ਸਮੇਂ ਦੇ ਵਿੰਡੋਜ਼ ਐਕਸਪੀ, ਵਿਸਟਾ, ਅਤੇ ਸਰਵਰ 1.0 ਲਈ ਪਾਵਰਸ਼ੇਲ 2003 ਜਾਰੀ ਕੀਤਾ। ਕੁਝ ਤਰੀਕਿਆਂ ਨਾਲ, ਇਸਨੇ cmdbat ਸਕ੍ਰਿਪਟਾਂ, vb ਸਕ੍ਰਿਪਟਾਂ, ਵਿੰਡੋਜ਼ ਸਕ੍ਰਿਪਟ ਹੋਸਟ ਅਤੇ JScript ਵਰਗੀਆਂ ਚੀਜ਼ਾਂ ਨੂੰ ਬਦਲ ਦਿੱਤਾ ਹੈ।

ਹੁਣ ਵੀ, ਲੂਪਸ, ਕਲਾਸਾਂ, ਫੰਕਸ਼ਨਾਂ, MS GUI ਕਾਲਾਂ ਦੀ ਮੌਜੂਦਗੀ ਦੇ ਬਾਵਜੂਦ, PowerShell ਨੂੰ ਲੋਗੋ ਵਿਕਲਪਾਂ ਤੋਂ ਬਾਅਦ ਸਿਰਫ ਅਗਲਾ ਕਦਮ ਮੰਨਿਆ ਜਾ ਸਕਦਾ ਹੈ, ਸੰਭਾਵਤ ਤੌਰ 'ਤੇ ਅਜੇ ਵੀ ਵਰਤੀ ਗਈ Delphi (ਜਾਂ ਕੁਝ ਪੁਰਾਣੀ) ਦੀ ਬਜਾਏ, Git ਏਕੀਕਰਣ ਅਤੇ ਇਸ 'ਤੇ.

Powershell ਦੀ ਵਰਤੋਂ ਮੁਕਾਬਲਤਨ ਘੱਟ ਹੀ ਕੀਤੀ ਜਾਂਦੀ ਹੈ; ਤੁਸੀਂ ਇਸਦਾ ਸਾਹਮਣਾ ਸਿਰਫ਼ PowerShell Core, VMware vSphere PowerCLI, Azure PowerShell, MS ਐਕਸਚੇਂਜ, ਲੋੜੀਦੀ ਸਟੇਟ ਕੌਂਫਿਗਰੇਸ਼ਨ, ਦੇ ਰੂਪ ਵਿੱਚ ਕਰ ਸਕਦੇ ਹੋ। PowerShell ਵੈੱਬ ਪਹੁੰਚ ਅਤੇ ਇੱਕ ਦਰਜਨ ਜਾਂ ਇਸ ਤੋਂ ਵੱਧ ਘੱਟ ਹੀ ਵਰਤੇ ਜਾਂਦੇ ਪ੍ਰੋਗਰਾਮ ਅਤੇ ਫੰਕਸ਼ਨ। ਸ਼ਾਇਦ ਉਸ ਨੂੰ ਰਿਲੀਜ਼ ਨਾਲ ਦੂਜੀ ਹਵਾ ਮਿਲੇਗੀ ਡਬਲਯੂਐਸਐਲ 2, ਪਰ ਇਹ ਬਿਲਕੁਲ ਨਹੀਂ ਹੈ।

ਪਾਵਰਸ਼ੇਲ ਦੇ ਤਿੰਨ ਵੱਡੇ ਫਾਇਦੇ ਵੀ ਹਨ:

1. ਇਹ ਮੁਕਾਬਲਤਨ ਸਧਾਰਨ ਹੈ, ਇਸ ਬਾਰੇ ਬਹੁਤ ਸਾਰਾ ਸਾਹਿਤ ਅਤੇ ਉਦਾਹਰਣਾਂ ਹਨ, ਅਤੇ ਇੱਥੋਂ ਤੱਕ ਕਿ ਰੂਸੀ ਵਿੱਚ, ਉਦਾਹਰਨ ਲਈ, ਫੋਰਚ ਬਾਰੇ ਇੱਕ ਲੇਖ - ਕਿਤਾਬ ਵਿੱਚੋਂ ਡੂੰਘਾਈ ਵਿੱਚ PowerShell - ਅੰਤਰ () ਅਤੇ {} ਬਾਰੇ
2. ਉਹ ਸੰਪਾਦਕ ਦੇ ਨਾਲ ਜਾਂਦਾ ਹੈ ISE, ਵਿੰਡੋਜ਼ ਦੇ ਨਾਲ ਸ਼ਾਮਲ ਹੈ। ਇੱਥੇ ਕਿਸੇ ਕਿਸਮ ਦਾ ਡੀਬਗਰ ਵੀ ਹੈ।
3. ਇਸ ਤੋਂ ਕਾਲ ਕਰਨਾ ਆਸਾਨ ਹੈ ਇੱਕ ਗਰਾਫੀਕਲ ਇੰਟਰਫੇਸ ਬਣਾਉਣ ਲਈ ਭਾਗ.

0. ਤਿਆਰੀ।

ਸਾਨੂੰ ਲੋੜ ਹੋਵੇਗੀ:

• ਵਿੰਡੋਜ਼ ਪੀਸੀ (ਮੇਰੇ ਕੋਲ ਵਿੰਡੋਜ਼ 10 ਹੈ)
• ਘੱਟੋ-ਘੱਟ ਕਿਸੇ ਕਿਸਮ ਦੀ ਇੰਟਰਨੈੱਟ ਪਹੁੰਚ (ਉਦਾਹਰਨ ਲਈ NAT ਰਾਹੀਂ)
• ਉਹਨਾਂ ਲਈ ਜਿਨ੍ਹਾਂ ਕੋਲ ਟੈਲੀਗ੍ਰਾਮ ਤੱਕ ਸੀਮਤ ਪਹੁੰਚ ਹੈ - ਬ੍ਰਾਊਜ਼ਰ ਵਿੱਚ ਫ੍ਰੀਗੇਟ ਨੂੰ ਸਥਾਪਿਤ ਅਤੇ ਸੰਰਚਿਤ ਕੀਤਾ ਗਿਆ ਹੈ, ਕੁਝ ਮੁਸ਼ਕਲ ਮਾਮਲਿਆਂ ਵਿੱਚ, ਸਿੰਪਲ DNS ਕ੍ਰਿਪਟ ਦੇ ਨਾਲ
• ਤੁਹਾਡੇ ਫ਼ੋਨ 'ਤੇ ਕੰਮ ਕਰਨ ਵਾਲਾ ਟੈਲੀਗ੍ਰਾਮ ਕਲਾਇੰਟ ਹੋਣਾ
• ਬਹੁਤ ਬੁਨਿਆਦੀ ਗੱਲਾਂ ਨੂੰ ਸਮਝਣਾ - ਇੱਕ ਵੇਰੀਏਬਲ, ਐਰੇ, ਲੂਪ ਕੀ ਹੈ।

ਲੇਖ ਖੋਲ੍ਹਿਆ ਅਤੇ ਪੜ੍ਹਿਆ - ਹਦਾਇਤਾਂ: ਟੈਲੀਗ੍ਰਾਮ ਵਿੱਚ ਬੋਟ ਕਿਵੇਂ ਬਣਾਉਣੇ ਹਨ и ਸਿਸਟਮ ਪ੍ਰਸ਼ਾਸਕ ਲਈ ਟੈਲੀਗ੍ਰਾਮ ਬੋਟ

1. ਚਲੋ ਇੱਕ ਹੋਰ ਟੈਸਟ ਬੋਟ ਬਣਾਈਏ।

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

ਸੰਬੰਧਿਤ ਸਮੱਸਿਆਵਾਂ: ਜੇਕਰ ਕਿਸੇ ਅਣਜਾਣ ਤਰੀਕੇ ਨਾਲ ਤੁਸੀਂ JSON ਵਸਤੂ ਤੋਂ ਕੁਝ ਕੋਡ ਲੈਂਦੇ ਹੋ ਅਤੇ ਕਿਸੇ ਤਰ੍ਹਾਂ ਇਸ ਨੂੰ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਲਈ ਭੇਜਦੇ ਹੋ (ਉਦੇਸ਼ 'ਤੇ ਨਹੀਂ), ਤਾਂ ਕੋਡ ਤੁਹਾਡੇ ਲਈ ਚਲਾਇਆ ਜਾਵੇਗਾ।

ਸਿਰਜਣ ਦੀ ਪ੍ਰਕਿਰਿਆ ਦਾ ਉਪਰੋਕਤ ਦੋ ਲੇਖਾਂ ਵਿੱਚ ਵਰਣਨ ਕੀਤਾ ਗਿਆ ਹੈ, ਪਰ ਮੈਂ ਦੁਹਰਾਉਂਦਾ ਹਾਂ: ਇੱਕ ਟੈਲੀਗ੍ਰਾਮ ਵਿੱਚ ਅਸੀਂ ਸੰਪਰਕ ਖੋਲ੍ਹਦੇ ਹਾਂ, @botfather ਨੂੰ ਲੱਭਦੇ ਹਾਂ, ਉਸਨੂੰ /newbot ਦੱਸਦੇ ਹਾਂ, ਇੱਕ ਬੋਟ Botfortest12344321 ਬਣਾਉਂਦੇ ਹਾਂ, ਇਸਨੂੰ Mynext1234bot ਕਹਿੰਦੇ ਹਾਂ, ਅਤੇ ਇੱਕ ਵਿਲੱਖਣ ਕੁੰਜੀ ਦੇ ਨਾਲ ਇੱਕ ਸੁਨੇਹਾ ਪ੍ਰਾਪਤ ਕਰਦੇ ਹਾਂ। ਫਾਰਮ 1234544311:AbcDefNNNNNNNNNNNNNN

ਕੁੰਜੀ ਦਾ ਧਿਆਨ ਰੱਖੋ ਅਤੇ ਇਸਨੂੰ ਨਾ ਦਿਓ!

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

ਆਓ BotFather ਨੂੰ “/mybot” ਲਈ ਪੁੱਛੀਏ ਅਤੇ ਸੈਟਿੰਗਾਂ ਨੂੰ ਵਿਵਸਥਿਤ ਕਰੀਏ ਜੇਕਰ ਸਾਨੂੰ ਕੁਝ ਪਸੰਦ ਨਹੀਂ ਹੈ।

ਆਓ ਸੰਪਰਕਾਂ ਨੂੰ ਦੁਬਾਰਾ ਖੋਲ੍ਹੀਏ, ਉੱਥੇ @Botfortest12344321 ਲੱਭੀਏ (@ ਨਾਲ ਖੋਜ ਸ਼ੁਰੂ ਕਰਨਾ ਲਾਜ਼ਮੀ ਹੈ), "ਸ਼ੁਰੂ ਕਰੋ" 'ਤੇ ਕਲਿੱਕ ਕਰੋ ਅਤੇ ਬੋਟ ਨੂੰ ਲਿਖੋ "/ਰੋਬੋਟਾਂ ਦੀ ਵਡਿਆਈ"। / ਚਿੰਨ੍ਹ ਦੀ ਲੋੜ ਹੈ, ਹਵਾਲੇ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ।
ਬੋਟ, ਬੇਸ਼ਕ, ਕੁਝ ਵੀ ਜਵਾਬ ਨਹੀਂ ਦੇਵੇਗਾ.

ਆਉ ਚੈੱਕ ਕਰੀਏ ਕਿ ਬੋਟ ਬਣਾਇਆ ਗਿਆ ਹੈ ਅਤੇ ਇਸਨੂੰ ਖੋਲ੍ਹੋ.

api.telegram.org/bot1234544311:AbcDefNNNNNNNNNNNNNN/getMe
ਜਿੱਥੇ 1234544311:AbcDefNNNNNNNNNNNNNN ਪਹਿਲਾਂ ਪ੍ਰਾਪਤ ਕੀਤੀ ਕੁੰਜੀ ਹੈ,
ਅਤੇ ਇੱਕ ਲਾਈਨ ਪ੍ਰਾਪਤ ਕਰੋ
{"ਠੀਕ ਹੈ":ਸੱਚਾ,"result":{""}}

ਸਾਡੇ ਕੋਲ ਪਹਿਲਾ ਗੁਪਤ ਵਾਕੰਸ਼ (ਟੋਕਨ) ਹੈ। ਹੁਣ ਸਾਨੂੰ ਦੂਜੇ ਗੁਪਤ ਨੰਬਰ ਦਾ ਪਤਾ ਲਗਾਉਣ ਦੀ ਜ਼ਰੂਰਤ ਹੈ - ਬੋਟ ਨਾਲ ਗੱਲਬਾਤ ਦੀ ਆਈ.ਡੀ. ਹਰੇਕ ਚੈਟ, ਸਮੂਹ, ਆਦਿ ਵਿਅਕਤੀਗਤ ਹੁੰਦਾ ਹੈ ਅਤੇ ਇਸਦਾ ਆਪਣਾ ਨੰਬਰ ਹੁੰਦਾ ਹੈ (ਕਈ ਵਾਰ ਘਟਾਓ ਨਾਲ - ਖੁੱਲੇ ਸਮੂਹਾਂ ਲਈ)। ਇਸ ਨੰਬਰ ਦਾ ਪਤਾ ਲਗਾਉਣ ਲਈ, ਸਾਨੂੰ ਬ੍ਰਾਊਜ਼ਰ ਵਿੱਚ ਬੇਨਤੀ ਕਰਨ ਦੀ ਲੋੜ ਹੈ (ਅਸਲ ਵਿੱਚ, ਬ੍ਰਾਊਜ਼ਰ ਵਿੱਚ ਇਹ ਬਿਲਕੁਲ ਜ਼ਰੂਰੀ ਨਹੀਂ ਹੈ, ਪਰ ਇੱਕ ਬਿਹਤਰ ਸਮਝ ਲਈ ਤੁਸੀਂ ਇਸ ਨਾਲ ਸ਼ੁਰੂ ਕਰ ਸਕਦੇ ਹੋ) ਪਤਾ (ਜਿੱਥੇ 1234544311:NNNNNNNNNN ਤੁਹਾਡਾ ਟੋਕਨ ਹੈ।

https://api.telegram.org/bot1234544311:NNNNNNNNN/getUpdates

ਅਤੇ ਇਸ ਤਰ੍ਹਾਂ ਦਾ ਜਵਾਬ ਪ੍ਰਾਪਤ ਕਰੋ

{"ਠੀਕ ਹੈ":true,"result":[{"update_id":...,... ਗੱਲਬਾਤ":{"id":123456789

ਸਾਨੂੰ chat_id ਦੀ ਲੋੜ ਹੈ।

ਚਲੋ ਜਾਂਚ ਕਰੀਏ ਕਿ ਅਸੀਂ ਚੈਟ ਨੂੰ ਮੈਨੂਅਲੀ ਲਿਖ ਸਕਦੇ ਹਾਂ: ਬ੍ਰਾਊਜ਼ਰ ਤੋਂ ਪਤੇ 'ਤੇ ਕਾਲ ਕਰੋ

https://api.telegram.org/botваштокен/sendMessage?chat_id=123456789&text="Life is directed motion"

ਜੇਕਰ ਤੁਸੀਂ ਆਪਣੀ ਚੈਟ ਵਿੱਚ ਇੱਕ ਬੋਟ ਤੋਂ ਇੱਕ ਸੁਨੇਹਾ ਪ੍ਰਾਪਤ ਕਰਦੇ ਹੋ, ਠੀਕ ਹੈ, ਤੁਸੀਂ ਅਗਲੇ ਪੜਾਅ 'ਤੇ ਜਾਂਦੇ ਹੋ।

ਇਸ ਤਰੀਕੇ ਨਾਲ (ਬ੍ਰਾਉਜ਼ਰ ਦੁਆਰਾ) ਤੁਸੀਂ ਹਮੇਸ਼ਾਂ ਜਾਂਚ ਕਰ ਸਕਦੇ ਹੋ ਕਿ ਲਿੰਕ ਬਣਾਉਣ ਵਿੱਚ ਸਮੱਸਿਆਵਾਂ ਹਨ, ਜਾਂ ਕੀ ਕੁਝ ਕਿਤੇ ਲੁਕਿਆ ਹੋਇਆ ਹੈ ਅਤੇ ਕੰਮ ਨਹੀਂ ਕਰਦਾ ਹੈ।

ਪੜ੍ਹਨਾ ਜਾਰੀ ਰੱਖਣ ਤੋਂ ਪਹਿਲਾਂ ਤੁਹਾਨੂੰ ਕੀ ਜਾਣਨ ਦੀ ਜ਼ਰੂਰਤ ਹੈ

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

ਚਲੋ ਮੰਨ ਲਓ ਕਿ ਇਹ 2019 ਦਾ ਅੰਤ ਹੈ, ਅਤੇ ਇੱਥੋਂ ਤੱਕ ਕਿ ਸਾਡੇ ਸਮੇਂ ਦਾ ਨਾਇਕ, ਮਸ਼ਹੂਰ ਮੈਨ-ਆਰਕੈਸਟਰਾ (ਪ੍ਰਬੰਧਕ, ਵਕੀਲ, ਸੂਚਨਾ ਸੁਰੱਖਿਆ ਮਾਹਰ, ਪ੍ਰੋਗਰਾਮਰ ਅਤੇ ਅਮਲੀ ਤੌਰ 'ਤੇ MVP) Evgeniy V. $i ਵੇਰੀਏਬਲ ਨੂੰ ਇੱਕ ਐਰੇ ਤੋਂ ਵੱਖ ਕਰਦਾ ਹੈ, ਲੂਪਸ ਵਿੱਚ ਮੁਹਾਰਤ ਹਾਸਲ ਕੀਤੀ ਹੈ, ਅਗਲੇ ਦੋ ਸਾਲਾਂ ਵਿੱਚ ਦੇਖੋ, ਚਾਕਲੇਟ ਵਿੱਚ ਮੁਹਾਰਤ ਹਾਸਲ ਕਰ ਲਵੇਗਾ, ਅਤੇ ਫਿਰ PowerShell ਨਾਲ ਸਮਾਨਾਂਤਰ ਪ੍ਰੋਸੈਸਿੰਗ и ਹਰ ਇਕ ਵਸਤੂ ਦੇ ਸਮਾਨਾਂਤਰ ਲਈ ਇਹ ਆ ਜਾਵੇਗਾ।

1. ਅਸੀਂ ਸੋਚਦੇ ਹਾਂ ਕਿ ਸਾਡਾ ਬੋਟ ਕੀ ਕਰੇਗਾ

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

AI ML ਤੋਂ ਬਿਨਾਂ ਬੋਟ-ਗਰੀਬ-ਕਵੀ-ਬੁਣਕਰ ਬਣਾਉਣਾ ਇੰਨਾ ਦਿਲਚਸਪ ਨਹੀਂ ਹੈ।

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

2. ਪਹਿਲੀ ਵਾਰ ਕੀ ਅਤੇ ਕਿਵੇਂ ਕੋਸ਼ਿਸ਼ ਕਰ ਰਿਹਾ ਹੈ

ਚਲੋ ਇੱਕ ਫੋਲਡਰ C:poshtranslate ਬਣਾਉ
ਪਹਿਲਾਂ, ਆਓ ਦੇਖੀਏ ਕਿ ਸਾਡੇ ਕੋਲ ਕਿਸ ਕਿਸਮ ਦਾ ਪਾਵਰਸ਼ੈਲ ਹੈ, ਆਓ ISE ਨੂੰ ਸਟਾਰਟ-ਰਨ ਰਾਹੀਂ ਲਾਂਚ ਕਰੀਏ
powershell ise
ਜਾਂ ਇੰਸਟਾਲ ਕੀਤੇ ਪ੍ਰੋਗਰਾਮਾਂ ਵਿੱਚ Powershell ISE ਲੱਭੋ।
ਲਾਂਚ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਆਮ ਜਾਣਿਆ-ਪਛਾਣਿਆ "ਕਿਸੇ ਕਿਸਮ ਦਾ ਸੰਪਾਦਕ" ਖੁੱਲ ਜਾਵੇਗਾ; ਜੇਕਰ ਕੋਈ ਟੈਕਸਟ ਖੇਤਰ ਨਹੀਂ ਹੈ, ਤਾਂ ਤੁਸੀਂ ਹਮੇਸ਼ਾਂ "ਫਾਈਲ - ਨਵਾਂ ਬਣਾਓ" 'ਤੇ ਕਲਿੱਕ ਕਰ ਸਕਦੇ ਹੋ।

ਆਉ ਪਾਵਰਸ਼ੇਲ ਦੇ ਸੰਸਕਰਣ ਨੂੰ ਵੇਖੀਏ - ਟੈਕਸਟ ਖੇਤਰ ਵਿੱਚ ਲਿਖੋ:

get-host 

ਅਤੇ F5 ਦਬਾਓ।

ਪਾਵਰਸ਼ੇਲ ਸੇਵ ਕਰਨ ਦੀ ਪੇਸ਼ਕਸ਼ ਕਰੇਗਾ - "ਜਿਸ ਸਕ੍ਰਿਪਟ ਨੂੰ ਤੁਸੀਂ ਚਲਾਉਣ ਜਾ ਰਹੇ ਹੋ, ਉਸਨੂੰ ਸੁਰੱਖਿਅਤ ਕੀਤਾ ਜਾਵੇਗਾ।", ਅਸੀਂ ਸਹਿਮਤ ਹਾਂ, ਅਤੇ C: poshtranslate ਵਿੱਚ ਨਾਮ ਦੇ ਨਾਲ Powershell ਤੋਂ ਫਾਈਲ ਨੂੰ ਸੁਰੱਖਿਅਤ ਕਰਦੇ ਹਾਂ। myfirstbotBT100.

ਲਾਂਚ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਹੇਠਲੇ ਟੈਕਸਟ ਵਿੰਡੋ ਵਿੱਚ ਸਾਨੂੰ ਇੱਕ ਡੇਟਾ ਟੇਬਲ ਮਿਲਦਾ ਹੈ:

Name             : Windows PowerShell ISE Host
Version          : 5.1.(и так далее)

ਮੇਰੇ ਕੋਲ 5.1 ਕੁਝ ਹੈ, ਇਹ ਕਾਫ਼ੀ ਹੈ। ਜੇਕਰ ਤੁਹਾਡੇ ਕੋਲ ਇੱਕ ਪੁਰਾਣਾ ਵਿੰਡੋਜ਼ 7/8 ਹੈ ਤਾਂ ਕੋਈ ਵੱਡੀ ਗੱਲ ਨਹੀਂ - ਹਾਲਾਂਕਿ PowerShell ਨੂੰ ਵਰਜਨ 5 ਵਿੱਚ ਅੱਪਡੇਟ ਕਰਨ ਦੀ ਲੋੜ ਹੋਵੇਗੀ - ਉਦਾਹਰਨ ਲਈ ਹਦਾਇਤਾਂ.

ਹੇਠਾਂ ਦਿੱਤੀ ਕਮਾਂਡ ਲਾਈਨ ਵਿੱਚ Get-Date ਟਾਈਪ ਕਰੋ, ਐਂਟਰ ਦਬਾਓ, ਸਮਾਂ ਦੇਖੋ, ਕਮਾਂਡ ਨਾਲ ਰੂਟ ਫੋਲਡਰ ਵਿੱਚ ਜਾਓ।
cd
ਅਤੇ cls ਕਮਾਂਡ ਨਾਲ ਸਕਰੀਨ ਨੂੰ ਸਾਫ਼ ਕਰੋ (ਨਹੀਂ, ਤੁਹਾਨੂੰ rm ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ)

ਹੁਣ ਆਓ ਦੇਖੀਏ ਕਿ ਕੀ ਕੰਮ ਕਰਦਾ ਹੈ ਅਤੇ ਕਿਵੇਂ - ਆਓ ਕੋਡ ਵੀ ਨਹੀਂ, ਪਰ ਦੋ ਲਾਈਨਾਂ ਲਿਖੀਏ, ਅਤੇ ਇਹ ਸਮਝਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੀਏ ਕਿ ਉਹ ਕੀ ਕਰਦੇ ਹਨ। ਆਓ # ਚਿੰਨ੍ਹ ਦੇ ਨਾਲ get-host ਦੇ ਨਾਲ ਲਾਈਨ ਨੂੰ ਟਿੱਪਣੀ ਕਰੀਏ ਅਤੇ ਥੋੜਾ ਜੋੜੀਏ।

# Пример шаблона бота 
# get-host
<# это пример многострочного комментария #>
$TimeNow = Get-Date
$TimeNow

(ਕੀ ਦਿਲਚਸਪ ਗੱਲ ਇਹ ਹੈ ਕਿ ਹੈਬਰੇ 'ਤੇ ਕੋਡ ਫਾਰਮੈਟਿੰਗ ਡ੍ਰੌਪ-ਡਾਉਨ ਸੂਚੀ ਵਿੱਚ ਦੋ ਦਰਜਨ ਵਿਕਲਪ ਹਨ - ਪਰ ਪਾਵਰਸ਼ੇਲ ਉੱਥੇ ਨਹੀਂ ਹੈ. ਡੌਸ ਉੱਥੇ ਹੈ. ਪਰਲ ਉੱਥੇ ਹੈ।)

ਅਤੇ GUI ਤੋਂ F5 ਜਾਂ ">" ਦਬਾ ਕੇ ਕੋਡ ਚਲਾਓ।

ਸਾਨੂੰ ਹੇਠ ਦਿੱਤੀ ਆਉਟਪੁੱਟ ਮਿਲਦੀ ਹੈ:

Saturday, December 8, 2019 21:00:50 PM (или что-то типа)

ਆਉ ਹੁਣ ਇਹਨਾਂ ਦੋ ਲਾਈਨਾਂ ਅਤੇ ਕੁਝ ਦਿਲਚਸਪ ਬਿੰਦੂਆਂ ਨੂੰ ਵੇਖੀਏ ਤਾਂ ਜੋ ਅਸੀਂ ਭਵਿੱਖ ਵਿੱਚ ਇਸ ਵੱਲ ਨਾ ਮੁੜੀਏ।

ਪਾਸਕਲ (ਅਤੇ ਨਾ ਸਿਰਫ) ਦੇ ਉਲਟ, PowerShell ਖੁਦ ਇਹ ਨਿਰਧਾਰਤ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦਾ ਹੈ ਕਿ ਇੱਕ ਵੇਰੀਏਬਲ ਨੂੰ ਕਿਸ ਕਿਸਮ ਨੂੰ ਸੌਂਪਣਾ ਹੈ; ਇਸ ਬਾਰੇ ਹੋਰ ਵੇਰਵੇ ਲੇਖ ਵਿੱਚ ਲਿਖੇ ਗਏ ਹਨ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾਵਾਂ ਵਿੱਚ ਟਾਈਪ ਕਰਨ 'ਤੇ ਵਿਦਿਅਕ ਪ੍ਰੋਗਰਾਮ
ਇਸ ਲਈ, ਇੱਕ $TimeNow ਵੇਰੀਏਬਲ ਬਣਾ ਕੇ ਅਤੇ ਇਸਨੂੰ ਮੌਜੂਦਾ ਮਿਤੀ ਅਤੇ ਸਮੇਂ (Get-date) ਦਾ ਮੁੱਲ ਨਿਰਧਾਰਤ ਕਰਕੇ, ਸਾਨੂੰ ਇਸ ਬਾਰੇ ਬਹੁਤ ਜ਼ਿਆਦਾ ਚਿੰਤਾ ਕਰਨ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ ਕਿ ਕਿਸ ਕਿਸਮ ਦਾ ਡੇਟਾ ਹੋਵੇਗਾ।

ਇਹ ਸੱਚ ਹੈ ਕਿ ਇਹ ਅਗਿਆਨਤਾ ਬਾਅਦ ਵਿੱਚ ਦੁਖੀ ਹੋ ਸਕਦੀ ਹੈ, ਪਰ ਇਹ ਬਾਅਦ ਵਿੱਚ ਹੈ। ਪਾਠ ਵਿੱਚ ਹੇਠਾਂ ਇੱਕ ਉਦਾਹਰਨ ਹੋਵੇਗੀ.
ਆਓ ਦੇਖੀਏ ਕਿ ਸਾਨੂੰ ਕੀ ਮਿਲਿਆ. ਚਲੋ (ਕਮਾਂਡ ਲਾਈਨ ਤੇ) ​​ਚਲਾਉਂਦੇ ਹਾਂ

$TimeNow | Get-member

ਅਤੇ ਨਾ ਸਮਝਣ ਯੋਗ ਟੈਕਸਟ ਦਾ ਇੱਕ ਪੰਨਾ ਪ੍ਰਾਪਤ ਕਰੋ

ਸਮਝ ਤੋਂ ਬਾਹਰ ਟੈਕਸਟ ਨੰਬਰ 1 ਦੀ ਉਦਾਹਰਨ

PS C:> $TimeNow | Get-member
   TypeName: System.DateTime
Name                 MemberType     Definition                                                                                                                                       
----                 ----------     ----------                                                                                                                                       
Add                  <b>Method         </b>datetime Add(timespan value)  
..
DisplayHint          NoteProperty   DisplayHintType DisplayHint=DateTime                                                                                                             
Date                 <b>Property       </b>datetime Date {get;}                                                                                                                             
Year                 Property       int Year {get;}   
..                                                                                                                               
DateTime             ScriptProperty System.Object DateTime {get=if ((& { Set-StrictMode -Version 1; $this.DisplayHint }) -ieq  "Date")...                                         

ਜਿਵੇਂ ਕਿ ਤੁਸੀਂ ਵੇਖ ਸਕਦੇ ਹੋ, ਕਿਸਮ ਦਾ ਇੱਕ ਵੇਰੀਏਬਲ TypeName: System.DateTime ਵਿਧੀਆਂ ਦੇ ਝੁੰਡ ਨਾਲ ਬਣਾਇਆ ਗਿਆ ਹੈ (ਇਸ ਅਰਥ ਵਿੱਚ ਕਿ ਅਸੀਂ ਇਸ ਵੇਰੀਏਬਲ ਆਬਜੈਕਟ ਨਾਲ ਕੀ ਕਰ ਸਕਦੇ ਹਾਂ) ਅਤੇ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ।

ਚਲੋ ਕਾਲ ਕਰੀਏ $TimeNow.DayOfYear - ਸਾਨੂੰ ਸਾਲ ਦੇ ਦਿਨ ਦੀ ਗਿਣਤੀ ਮਿਲਦੀ ਹੈ।
ਚਲੋ ਕਾਲ ਕਰੀਏ $TimeNow.DayOfYear | Get-Member - ਸਾਨੂੰ ਪ੍ਰਾਪਤ TypeName: System.Int32 ਅਤੇ ਢੰਗਾਂ ਦਾ ਇੱਕ ਸਮੂਹ।
ਚਲੋ ਕਾਲ ਕਰੀਏ $TimeNow.ToUniversalTime() - ਅਤੇ UTC ਵਿੱਚ ਸਮਾਂ ਪ੍ਰਾਪਤ ਕਰੋ

ਡੀਬੱਗਰ

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

3. ਟੈਲੀਗ੍ਰਾਮ ਬੋਟ ਨਾਲ ਗੱਲਬਾਤ ਨੂੰ ਸਮਝਣਾ

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

ਸਾਡੇ ਕੇਸ ਵਿੱਚ ਇਹ ਜ਼ਰੂਰੀ ਹੈ:

• ਪੱਤਰ ਵਿਹਾਰ ਵਿੱਚ ਕੁਝ ਭੇਜਣਾ ਸਿੱਖੋ
• ਪੱਤਰ ਵਿਹਾਰ ਤੋਂ ਕੁਝ ਪ੍ਰਾਪਤ ਕਰਨਾ ਸਿੱਖੋ

3.1 ਪੱਤਰ-ਵਿਹਾਰ ਵਿੱਚ ਕੁਝ ਭੇਜਣਾ ਅਤੇ ਇਸ ਤੋਂ ਪ੍ਰਾਪਤ ਕਰਨਾ ਸਿੱਖਣਾ

ਇੱਕ ਛੋਟਾ ਕੋਡ - ਭਾਗ 3

Write-output "This is part 3"
$MyToken = "1234544311:AbcDefNNNNNNNNNNNNN"
$MyChatID = "123456789"
$MyProxy = "http://1.2.3.4:5678" 

$TimeNow = Get-Date
$TimeNow.ToUniversalTime()
$ScriptDir = Split-Path $script:MyInvocation.MyCommand.Path
$BotVersion = "BT102"

$MyText01 = "Life is directed motion - " + $TimeNow

$URL4SEND = "https://api.telegram.org/bot$MyToken/sendMessage?chat_id=$MyChatID&text=$MyText01"

Invoke-WebRequest -Uri $URL4SEND

ਅਤੇ ਇਸ ਸਮੇਂ ਰਸ਼ੀਅਨ ਫੈਡਰੇਸ਼ਨ ਵਿੱਚ ਸਾਨੂੰ ਰਿਮੋਟ ਸਰਵਰ ਨਾਲ ਜੁੜਨ ਵਿੱਚ ਅਸਮਰੱਥ ਗਲਤੀ ਮਿਲਦੀ ਹੈ।

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

ਕਾਰਜਸ਼ੀਲ ਪ੍ਰੌਕਸੀ ਲੱਭਣ ਦਾ ਕੰਮ ਬਹੁਤ ਮੁਸ਼ਕਲ ਨਹੀਂ ਹੈ - ਜ਼ਿਆਦਾਤਰ ਪ੍ਰਕਾਸ਼ਿਤ http ਪ੍ਰੌਕਸੀ ਕੰਮ ਕਰਦੇ ਹਨ. ਮੈਨੂੰ ਲਗਦਾ ਹੈ ਕਿ ਪੰਜਵੇਂ ਨੇ ਮੇਰੇ ਲਈ ਕੰਮ ਕੀਤਾ.

ਪ੍ਰੌਕਸੀ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਸੰਟੈਕਸ:

Invoke-WebRequest -Uri $URL4SEND -Proxy $MyProxy

ਜੇ ਤੁਸੀਂ ਇੱਕ ਬੋਟ ਨਾਲ ਆਪਣੀ ਗੱਲਬਾਤ ਵਿੱਚ ਇੱਕ ਸੁਨੇਹਾ ਪ੍ਰਾਪਤ ਕਰਦੇ ਹੋ, ਤਾਂ ਸਭ ਕੁਝ ਠੀਕ ਹੈ, ਤੁਸੀਂ ਅੱਗੇ ਵਧ ਸਕਦੇ ਹੋ। ਜੇਕਰ ਨਹੀਂ, ਤਾਂ ਡੀਬੱਗਿੰਗ ਜਾਰੀ ਰੱਖੋ।

ਤੁਸੀਂ ਦੇਖ ਸਕਦੇ ਹੋ ਕਿ ਤੁਹਾਡੀ $URL4SEND ਸਤਰ ਕਿਸ ਵਿੱਚ ਬਦਲਦੀ ਹੈ ਅਤੇ ਇਸਨੂੰ ਬ੍ਰਾਊਜ਼ਰ ਵਿੱਚ ਬੇਨਤੀ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੋ, ਇਸ ਤਰ੍ਹਾਂ:

$URL4SEND2 = '"'+$URL4SEND+'"'
start chrome $URL4SEND2 

3.2 ਅਸੀਂ ਚੈਟ ਵਿੱਚ "ਕੁਝ" ਲਿਖਣਾ ਸਿੱਖਿਆ, ਹੁਣ ਇਸਨੂੰ ਪੜ੍ਹਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੀਏ

ਆਓ 4 ਹੋਰ ਲਾਈਨਾਂ ਜੋੜੀਏ ਅਤੇ ਵੇਖੀਏ ਕਿ ਅੰਦਰ ਕੀ ਹੈ | ਮੈਂਬਰ ਪ੍ਰਾਪਤ ਕਰੋ

$URLGET = "https://api.telegram.org/bot$MyToken/getUpdates"
$MyMessageGet = Invoke-WebRequest -Uri $URLGET -Method Get -Proxy $MyProxy
Write-Host "Get-Member"
$MyMessageGet | Get-Member

ਸਭ ਤੋਂ ਦਿਲਚਸਪ ਚੀਜ਼ ਸਾਨੂੰ ਪ੍ਰਦਾਨ ਕੀਤੀ ਜਾਂਦੀ ਹੈ

Content           Property   string Content {get;}  
ParsedHtml        Property   mshtml.IHTMLDocument2 ParsedHtml {get;}                                    
RawContent        Property   string RawContent {get;set;}

ਆਓ ਦੇਖੀਏ ਉਨ੍ਹਾਂ ਵਿੱਚ ਕੀ ਹੈ:

Write-Host "ParsedHtml"
$MyMessageGet.ParsedHtml # тут интересное
Write-Host "RawContent"
$MyMessageGet.RawContent # и тут интересное, но еще к тому же и читаемое. 
Write-Host "Content"
$MyMessageGet.Content

ਜੇ ਸਭ ਕੁਝ ਤੁਹਾਡੇ ਲਈ ਕੰਮ ਕਰਦਾ ਹੈ, ਤਾਂ ਤੁਹਾਨੂੰ ਇੱਕ ਲੰਬੀ ਲਾਈਨ ਮਿਲੇਗੀ ਜਿਵੇਂ ਕਿ:

{"ok":true,"result":[{"update_id":12345678,
"message":{"message_id":3,"from":{"id"

ਖੁਸ਼ਕਿਸਮਤੀ ਨਾਲ, ਸਿਸਟਮ ਪ੍ਰਸ਼ਾਸਕ ਲਈ ਪਹਿਲਾਂ ਪ੍ਰਕਾਸ਼ਿਤ ਲੇਖ ਟੈਲੀਗ੍ਰਾਮ ਬੋਟ ਵਿੱਚ ਇਹ ਲਾਈਨ (ਹਾਂ, $MyMessageGet.RawContent | ਦੇ ਅਨੁਸਾਰ get-member ਹੈ System.String), ਪਹਿਲਾਂ ਹੀ ਵੱਖ ਕੀਤਾ ਜਾ ਚੁੱਕਾ ਹੈ।

4. ਜੋ ਤੁਸੀਂ ਪ੍ਰਾਪਤ ਕਰਦੇ ਹੋ ਉਸ 'ਤੇ ਪ੍ਰਕਿਰਿਆ ਕਰੋ (ਅਸੀਂ ਪਹਿਲਾਂ ਹੀ ਜਾਣਦੇ ਹਾਂ ਕਿ ਕੁਝ ਕਿਵੇਂ ਭੇਜਣਾ ਹੈ)

ਜਿਵੇਂ ਕਿ ਪਹਿਲਾਂ ਹੀ ਲਿਖਿਆ ਗਿਆ ਹੈ ਇੱਥੇ, ਸਭ ਤੋਂ ਜ਼ਰੂਰੀ ਚੀਜ਼ਾਂ ਸਮੱਗਰੀ ਵਿੱਚ ਹੁੰਦੀਆਂ ਹਨ। ਆਓ ਇਸ 'ਤੇ ਡੂੰਘਾਈ ਨਾਲ ਵਿਚਾਰ ਕਰੀਏ।

ਪਹਿਲਾਂ, ਅਸੀਂ ਵੈੱਬ ਇੰਟਰਫੇਸ ਜਾਂ ਫ਼ੋਨ ਤੋਂ ਬੋਟ ਨੂੰ ਕੁਝ ਹੋਰ ਵਾਕਾਂਸ਼ ਲਿਖਾਂਗੇ

/message1
/message2
/message3

ਅਤੇ ਬ੍ਰਾਊਜ਼ਰ ਨੂੰ ਉਸ ਪਤੇ 'ਤੇ ਦੇਖੋ ਜੋ $URLGET ਵੇਰੀਏਬਲ ਵਿੱਚ ਬਣਿਆ ਸੀ।

ਅਸੀਂ ਕੁਝ ਅਜਿਹਾ ਵੇਖਾਂਗੇ:

{"ok":true,"result":[{"update_id":NNNNNNN,
"message":{"message_id":10, .. "text":"/message1"
"message":{"message_id":11, .. "text":"/message2 
"message":{"message_id":12, .. "text":"/message3 

ਇਹ ਕੀ ਹੈ? ਆਬਜੈਕਟ ਦੇ ਐਰੇ ਤੋਂ ਕੁਝ ਗੁੰਝਲਦਾਰ ਆਬਜੈਕਟ ਜਿਸ ਵਿੱਚ ਅੰਤ-ਤੋਂ-ਅੰਤ ਸੁਨੇਹਾ ਪਛਾਣਕਰਤਾ, ਚੈਟ ਪਛਾਣਕਰਤਾ, ਭੇਜਣ ਪਛਾਣਕਰਤਾ ਅਤੇ ਹੋਰ ਬਹੁਤ ਸਾਰੀ ਜਾਣਕਾਰੀ ਹੁੰਦੀ ਹੈ।

ਹਾਲਾਂਕਿ, ਸਾਨੂੰ ਇਹ ਪਤਾ ਲਗਾਉਣ ਦੀ ਜ਼ਰੂਰਤ ਨਹੀਂ ਹੈ ਕਿ "ਇਹ ਕਿਸ ਕਿਸਮ ਦੀ ਵਸਤੂ ਹੈ" - ਕੰਮ ਦਾ ਹਿੱਸਾ ਸਾਡੇ ਲਈ ਪਹਿਲਾਂ ਹੀ ਕੀਤਾ ਜਾ ਚੁੱਕਾ ਹੈ। ਆਓ ਦੇਖੀਏ ਕਿ ਅੰਦਰ ਕੀ ਹੈ:

ਪ੍ਰਾਪਤ ਸੁਨੇਹੇ ਪੜ੍ਹਨਾ ਜਾਂ ਭਾਗ 4

Write-Host "This is part 4" <# конечно эта строка нам не нужна в итоговом тексте, но по ней удобно искать. #> 

$Content4Pars01 = ConvertFrom-Json $MyMessageGet.Content
$Content4Pars01 | Get-Member
$Content4Pars01.result
$Content4Pars01.result[0]
$Content4Pars01.result[0] | Get-Member
$Content4Pars01.result[0].update_id
$Content4Pars01.result[0].message
$Content4Pars01.result[0].message.text
$Content4Pars01.result[1].message.text
$Content4Pars01.result[2].message.text

5. ਸਾਨੂੰ ਹੁਣ ਇਸ ਬਾਰੇ ਕੀ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ?

ਚਲੋ ਨਤੀਜੇ ਵਾਲੀ ਫਾਈਲ ਨੂੰ myfirstbotBT105 ਨਾਮ ਦੇ ਹੇਠਾਂ ਸੇਵ ਕਰੀਏ ਜਾਂ ਜੋ ਵੀ ਤੁਹਾਨੂੰ ਸਭ ਤੋਂ ਵਧੀਆ ਪਸੰਦ ਹੈ, ਸਿਰਲੇਖ ਨੂੰ ਬਦਲੋ ਅਤੇ ਸਾਰੇ ਪਹਿਲਾਂ ਤੋਂ ਲਿਖੇ ਕੋਡ ਦੁਆਰਾ ਟਿੱਪਣੀ ਕਰੋ

<#start comment 105 end comment 105#>

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

ਬੇਸ਼ੱਕ, ਤੁਸੀਂ ਸਕ੍ਰਿਪਟ ਦੇ ਪਾਠ ਵਿੱਚ ਇੱਕ ਵਿਸ਼ਾਲ ਸ਼ਬਦਕੋਸ਼ ਲਿਖ ਸਕਦੇ ਹੋ, ਪਰ ਇਹ ਬਿੰਦੂ ਦੇ ਬਿਲਕੁਲ ਨਾਲ ਹੈ।
ਤਾਂ ਆਓ ਦੇਖੀਏ ਕਿ ਪਾਵਰਸ਼ੇਲ ਆਮ ਤੌਰ 'ਤੇ ਕਿਸ ਨਾਲ ਕੰਮ ਕਰ ਸਕਦਾ ਹੈ।
ਆਮ ਤੌਰ 'ਤੇ, ਉਹ ਪਰਵਾਹ ਨਹੀਂ ਕਰਦਾ ਕਿ ਕਿਹੜੀ ਫਾਈਲ ਨਾਲ ਕੰਮ ਕਰਨਾ ਹੈ, ਇਸ ਨਾਲ ਸਾਡੇ ਲਈ ਕੋਈ ਫਰਕ ਨਹੀਂ ਪੈਂਦਾ।
ਸਾਡੇ ਕੋਲ ਇੱਕ ਵਿਕਲਪ ਹੈ: txt (ਤੁਸੀਂ ਕਰ ਸਕਦੇ ਹੋ, ਪਰ ਕਿਉਂ), csv, xml.
ਕੀ ਅਸੀਂ ਹਰ ਕਿਸੇ ਨੂੰ ਦੇਖ ਸਕਦੇ ਹਾਂ?
ਚਲੋ ਇੱਕ ਕਲਾਸ MyVocabClassExample1 ਅਤੇ ਇੱਕ ਵੇਰੀਏਬਲ $MyVocabExample1 ਬਣਾਈਏ।
ਮੈਂ ਨੋਟ ਕਰਦਾ ਹਾਂ ਕਿ ਕਲਾਸ $ ਤੋਂ ਬਿਨਾਂ ਲਿਖੀ ਜਾਂਦੀ ਹੈ

ਕੁਝ ਕੋਡ #5

write-host "This is part 5"
class MyVocabClassExample1 {
    [string]$Original  # слово
    [string]$Transcript
    [string]$Translate
    [string]$Example
    [int]$VocWordID # очень интересный момент. Использование int с его ограничениями может порой приводить к диким последствиям, для примера - недавний случай с SSD HPE. Изначально я не стал добавлять этот элемент, потом все же дописал и закомментировал.
    }

$MyVocabExample1 = [MyVocabClassExample1]::new()
$MyVocabExample1.Original = "Apple"
$MyVocabExample1.Transcript = "[ ˈapəl ]"
$MyVocabExample1.Translate = "Яблоко"
$MyVocabExample1.Example = "An apple is a sweet, edible fruit produced by an apple tree (Malus domestica)"
# $MyVocabExample1.$VocWordID = 1

$MyVocabExample2 = [MyVocabClassExample1]::new()
$MyVocabExample2.Original = "Pear"
$MyVocabExample2.Transcript = "[ pe(ə)r ]"
$MyVocabExample2.Translate = "Груша"
$MyVocabExample2.Example = "The pear (/ˈpɛər/) tree and shrub are a species of genus Pyrus"
# $MyVocabExample1.$VocWordID = 2

ਆਉ ਇਸਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇਸਨੂੰ ਫਾਈਲਾਂ ਵਿੱਚ ਲਿਖਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੀਏ ਨਮੂਨਾ.

ਕੁਝ ਕੋਡ #5.1

Write-Host $ScriptDir # надеюсь $ScriptDir вы не закомментировали 
$MyFilenameExample01 = $ScriptDir + "Example01.txt"
$MyFilenameExample02 = $ScriptDir + "Example02.txt"
Write-Host $MyFilenameExample01
Out-File  -FilePath $MyFilenameExample01 -InputObject $MyVocabExample1

Out-File  -FilePath $MyFilenameExample01 -InputObject -Append $MyVocabExample2
notepad $MyFilenameExample01

- ਅਤੇ ਸਾਨੂੰ Out-File -FilePath $MyFilenameExample01 -InputObject -Append $MyVocabExample2 ਲਾਈਨ 'ਤੇ ਇੱਕ ਗਲਤੀ ਮਿਲਦੀ ਹੈ।

ਉਹ ਸ਼ਾਮਲ ਨਹੀਂ ਕਰਨਾ ਚਾਹੁੰਦਾ, ਆਹ-ਆਹ, ਕਿੰਨੀ ਸ਼ਰਮ ਦੀ ਗੱਲ ਹੈ।

$MyVocabExample3AsArray = @($MyVocabExample1,$MyVocabExample2)
Out-File  -FilePath $MyFilenameExample02 -InputObject $MyVocabExample3AsArray
notepad $MyFilenameExample02

ਆਓ ਦੇਖੀਏ ਕੀ ਹੁੰਦਾ ਹੈ। ਸ਼ਾਨਦਾਰ ਟੈਕਸਟ ਦ੍ਰਿਸ਼ - ਪਰ ਇਸਨੂੰ ਵਾਪਸ ਕਿਵੇਂ ਨਿਰਯਾਤ ਕਰਨਾ ਹੈ? ਕੀ ਮੈਨੂੰ ਕਿਸੇ ਕਿਸਮ ਦੇ ਟੈਕਸਟ ਵੱਖ ਕਰਨ ਵਾਲੇ ਪੇਸ਼ ਕਰਨੇ ਚਾਹੀਦੇ ਹਨ, ਜਿਵੇਂ ਕਿ ਕਾਮੇ?

ਅਤੇ ਅੰਤ ਵਿੱਚ ਤੁਹਾਨੂੰ ਇੱਕ “ਕੌਮੇ ਨਾਲ ਵੱਖ ਕੀਤੇ ਮੁੱਲ (CSV) ਫਾਈਲ ਏ ਮਿਲਦੀ ਹੈ ਉਡੀਕ ਕਰੋ.
#

$MyFilenameExample03 = $ScriptDir + "Example03.csv"
$MyFilenameExample04 = $ScriptDir + "Example04.csv"
Export-Csv  -Path $MyFilenameExample03 -InputObject $MyVocabExample1 
Export-Csv  -Path $MyFilenameExample03 -InputObject $MyVocabExample2 -Append 
Export-Csv  -Path $MyFilenameExample04 -InputObject $MyVocabExample3AsArray 

ਜਿਵੇਂ ਕਿ ਵੇਖਣਾ ਆਸਾਨ ਹੈ, MS ਨੂੰ ਇਸਦੇ ਤਰਕ ਦੁਆਰਾ ਖਾਸ ਤੌਰ 'ਤੇ ਵੱਖਰਾ ਨਹੀਂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ; ਇੱਕ ਸਮਾਨ ਪ੍ਰਕਿਰਿਆ ਲਈ, ਇੱਕ ਕੇਸ ਵਿੱਚ -FilePath ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਦੂਜੇ ਵਿੱਚ -Path.

ਇਸ ਤੋਂ ਇਲਾਵਾ, ਤੀਜੀ ਫਾਈਲ ਵਿਚ ਰੂਸੀ ਭਾਸ਼ਾ ਗਾਇਬ ਹੋ ਗਈ, ਚੌਥੀ ਫਾਈਲ ਵਿਚ ਇਹ ਨਿਕਲਿਆ ... ਠੀਕ ਹੈ, ਕੁਝ ਹੋਇਆ. #TYPE System.Object[] 00
# “ਗਿਣਤੀ”,”ਲੰਬਾਈ”,”ਲੰਬਾਈ”,”ਰੈਂਕ”,”ਸਿੰਕਰਰੂਟ”,”ਇਸਰੇਡਓਨਲੀ”,”ਇਸਫਿਕਸਡਸਾਈਜ਼”,”ਇਸ ਸਿੰਕ੍ਰੋਨਾਈਜ਼ਡ”
#
ਆਓ ਇਸਨੂੰ ਥੋੜਾ ਜਿਹਾ ਦੁਬਾਰਾ ਲਿਖੀਏ:

Export-Csv  -Path $MyFilenameExample03 -InputObject $MyVocabExample1 -Encoding Unicode
Export-Csv  -Path $MyFilenameExample03 -InputObject $MyVocabExample2 -Append -Encoding Unicode
notepad $MyFilenameExample03
notepad $MyFilenameExample04

ਇਹ ਮਦਦ ਕਰਦਾ ਜਾਪਦਾ ਹੈ, ਪਰ ਮੈਨੂੰ ਅਜੇ ਵੀ ਫਾਰਮੈਟ ਪਸੰਦ ਨਹੀਂ ਹੈ।

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

ਇਹ ਸੱਚ ਹੈ ਕਿ ਅਜੇ ਲਿਖਣ ਲਈ ਕੁਝ ਨਹੀਂ ਹੈ, ਪਰ ਤੁਸੀਂ ਇਸ ਬਾਰੇ ਸੋਚ ਸਕਦੇ ਹੋ ਕਿ ਲੌਗਸ ਨੂੰ ਕਿਵੇਂ ਘੁੰਮਾਉਣਾ ਹੈ।
ਚਲੋ ਹੁਣ ਲਈ xml ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੀਏ।

ਕੁਝ xml

$MyFilenameExample05 = $ScriptDir + "Example05.xml"
$MyFilenameExample06 = $ScriptDir + "Example06.xml"
Export-Clixml  -Path $MyFilenameExample05 -InputObject $MyVocabExample1 
Export-Clixml  -Path $MyFilenameExample05 -InputObject $MyVocabExample2 -Append -Encoding Unicode
Export-Clixml  -Path $MyFilenameExample06 -InputObject $MyVocabExample3AsArray
notepad $MyFilenameExample05
notepad $MyFilenameExample06

xml ਵਿੱਚ ਨਿਰਯਾਤ ਕਰਨ ਦੇ ਬਹੁਤ ਸਾਰੇ ਫਾਇਦੇ ਹਨ - ਪੜ੍ਹਨਯੋਗਤਾ, ਸਮੁੱਚੀ ਵਸਤੂ ਦਾ ਨਿਰਯਾਤ, ਅਤੇ ਇੱਕ ਅੱਪਪੇਂਡ ਕਰਨ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ।

ਆਓ xml ਫਾਈਲ ਪੜ੍ਹੋ.

xml ਤੋਂ ਥੋੜਾ ਜਿਹਾ ਪੜ੍ਹਨਾ

$MyFilenameExample06 = $ScriptDir + "Example06.xml"
$MyVocabExample4AsArray = Import-Clixml -Path $MyFilenameExample06
# $MyVocabExample4AsArray 
# $MyVocabExample4AsArray[0]
# и немного о совершенно неочевидных нюансах. Powershell время от времени ведет себя не так, как вроде бы как бы стоило бы ожидать бы.
# например у меня эти два вывода отличаются
# Write-Output $MyVocabExample4AsArray 
# write-host $MyVocabExample4AsArray 

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

ਮੈਨੂੰ ਤੁਹਾਨੂੰ ਯਾਦ ਦਿਵਾਉਣ ਦਿਓ ਕਿ ਕੰਮ ਇੱਕ ਛੋਟਾ ਸਿਖਲਾਈ ਬੋਟ ਬਣਾਉਣਾ ਸੀ.

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

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

ਓ ਹਾਂ. ਆਓ ਬੋਟ ਨੂੰ ਦੁਬਾਰਾ ਕੁਝ ਭੇਜੀਏ।

6. ਫੰਕਸ਼ਨਾਂ ਅਤੇ ਹੋਰਾਂ ਤੋਂ ਡਿਸਪੈਚ ਕਰੋ

ਰਿਸੈਪਸ਼ਨ 'ਤੇ ਕਾਰਵਾਈ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ, ਤੁਹਾਨੂੰ ਟੈਸਟ ਸੰਦੇਸ਼ ਤੋਂ ਇਲਾਵਾ "ਘੱਟੋ-ਘੱਟ ਕੁਝ" ਭੇਜਣ ਲਈ ਇੱਕ ਫੰਕਸ਼ਨ ਬਣਾਉਣ ਦੀ ਲੋੜ ਹੈ।

ਬੇਸ਼ੱਕ, ਉਦਾਹਰਨ ਵਿੱਚ ਸਾਡੇ ਕੋਲ ਸਿਰਫ਼ ਇੱਕ ਭੇਜਣਾ ਹੋਵੇਗਾ ਅਤੇ ਸਿਰਫ਼ ਇੱਕ ਹੀ ਪ੍ਰੋਸੈਸਿੰਗ ਹੋਵੇਗੀ, ਪਰ ਉਦੋਂ ਕੀ ਜੇ ਸਾਨੂੰ ਇੱਕੋ ਚੀਜ਼ ਨੂੰ ਕਈ ਵਾਰ ਕਰਨ ਦੀ ਲੋੜ ਹੈ?

ਫੰਕਸ਼ਨ ਲਿਖਣਾ ਸੌਖਾ ਹੈ। ਇਸ ਲਈ, ਸਾਡੇ ਕੋਲ ਔਬਜੈਕਟ $MyVocabExample4AsArray ਦਾ ਇੱਕ ਵੇਰੀਏਬਲ ਹੈ, ਜੋ ਕਿ ਫਾਈਲ ਤੋਂ ਪੜ੍ਹਿਆ ਗਿਆ ਹੈ, ਵੱਧ ਤੋਂ ਵੱਧ ਦੋ ਤੱਤਾਂ ਦੀ ਇੱਕ ਐਰੇ ਦੇ ਰੂਪ ਵਿੱਚ।
ਚਲੋ ਪੜ੍ਹਦੇ ਹਾਂ।

ਉਸੇ ਸਮੇਂ, ਅਸੀਂ ਘੜੀ ਨਾਲ ਨਜਿੱਠਾਂਗੇ; ਸਾਨੂੰ ਬਾਅਦ ਵਿੱਚ ਇਸਦੀ ਲੋੜ ਪਵੇਗੀ (ਅਸਲ ਵਿੱਚ, ਇਸ ਉਦਾਹਰਣ ਵਿੱਚ ਸਾਨੂੰ ਇਸਦੀ ਲੋੜ ਨਹੀਂ ਹੋਵੇਗੀ :)

ਕੁਝ ਕੋਡ #6.1

Write-Output "This is Part 6"
$Timezone = (Get-TimeZone)
IF($Timezone.SupportsDaylightSavingTime -eq $True){
    $TimeAdjust =  ($Timezone.BaseUtcOffset.TotalSeconds + 3600) } # приведенное время
    ELSE{$TimeAdjust = ($Timezone.BaseUtcOffset.TotalSeconds) 
    }
    
function MyFirstFunction($SomeExampleForFunction1){
$TimeNow = Get-Date
$TimeNow.ToUniversalTime()
# $MyText02 = $TimeNow + " " + $SomeExampleForFunction1 # и вот тут мы получим ошибку
$MyText02 = $SomeExampleForFunction1 + " " + $TimeNow # а тут не получим, кто догадается почему - тот молодец.

$URL4SendFromFunction = "https://api.telegram.org/bot$MyToken/sendMessage?chat_id=$MyChatID&text=$MyText02"
Invoke-WebRequest -Uri $URL4SendFromFunction -Proxy $MyProxy
}

ਜਿਵੇਂ ਕਿ ਤੁਸੀਂ ਆਸਾਨੀ ਨਾਲ ਦੇਖ ਸਕਦੇ ਹੋ, ਫੰਕਸ਼ਨ $MyToken ਅਤੇ $MyChatID ਨੂੰ ਕਾਲ ਕਰਦਾ ਹੈ, ਜੋ ਪਹਿਲਾਂ ਹਾਰਡ-ਕੋਡ ਕੀਤੇ ਗਏ ਸਨ।

ਅਜਿਹਾ ਕਰਨ ਦੀ ਕੋਈ ਲੋੜ ਨਹੀਂ ਹੈ, ਅਤੇ ਜੇਕਰ $MyToken ਹਰੇਕ ਬੋਟ ਲਈ ਇੱਕ ਹੈ, ਤਾਂ $MyChatID ਚੈਟ ਦੇ ਆਧਾਰ 'ਤੇ ਬਦਲ ਜਾਵੇਗਾ।

ਹਾਲਾਂਕਿ, ਕਿਉਂਕਿ ਇਹ ਇੱਕ ਉਦਾਹਰਣ ਹੈ, ਅਸੀਂ ਇਸ ਨੂੰ ਫਿਲਹਾਲ ਨਜ਼ਰਅੰਦਾਜ਼ ਕਰਾਂਗੇ।

ਕਿਉਂਕਿ $MyVocabExample4AsArray ਇੱਕ ਐਰੇ ਨਹੀਂ ਹੈ, ਹਾਲਾਂਕਿ ਇਹ ਇੱਕ ਦੇ ਸਮਾਨ ਹੈ, ਫਿਰ ਤੁਸੀਂ ਇਸਨੂੰ ਨਹੀਂ ਲੈ ਸਕਦੇ ਇਸਦੀ ਲੰਬਾਈ ਲਈ ਬੇਨਤੀ ਕਰੋ।

ਇੱਕ ਵਾਰ ਫਿਰ ਸਾਨੂੰ ਕੁਝ ਅਜਿਹਾ ਕਰਨਾ ਪਏਗਾ ਜੋ ਨਹੀਂ ਕੀਤਾ ਜਾ ਸਕਦਾ - ਪੈਰਾਸ਼ੂਟ ਕੋਡ ਦੇ ਅਨੁਸਾਰ ਨਹੀਂ - ਇਸਨੂੰ ਲਓ ਅਤੇ ਗਿਣੋ

ਕੁਝ ਕੋਡ #6.2

$MaxRandomExample = 0 
foreach ($Obj in $MyVocabExample4AsArray) {
$MaxRandomExample ++
}
Write-Output $MaxRandomExample
$RandomExample = Get-Random -Minimum 0 -Maximum ($MaxRandomExample)
$TextForExample1 = $MyVocabExample4AsArray[$RandomExample].Original
# MyFirstFunction($TextForExample1)
# или в одну строку
# MyFirstFunction($MyVocabExample4AsArray[Get-Random -Minimum 0 -Maximum ($MaxRandomExample -1)].Example)
# Угадайте сами, какой пример легче читается посторонними людьми.

ਬੇਤਰਤੀਬੇ ਦਿਲਚਸਪ ਵਿਸ਼ੇਸ਼ਤਾ. ਮੰਨ ਲਓ ਕਿ ਅਸੀਂ 0 ਜਾਂ 1 ਪ੍ਰਾਪਤ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹਾਂ (ਸਾਡੇ ਕੋਲ ਐਰੇ ਵਿੱਚ ਸਿਰਫ ਦੋ ਤੱਤ ਹਨ)। ਜਦੋਂ ਸੀਮਾਵਾਂ 0..1 ਨਿਰਧਾਰਤ ਕੀਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ, ਤਾਂ ਕੀ ਸਾਨੂੰ "1" ਮਿਲੇਗਾ?
ਨਹੀਂ - ਸਾਨੂੰ ਇਹ ਨਹੀਂ ਮਿਲੇਗਾ, ਸਾਡੇ ਕੋਲ ਇੱਕ ਵਿਸ਼ੇਸ਼ ਉਦਾਹਰਨ ਹੈ ਉਦਾਹਰਨ 2: 0 ਅਤੇ 99 ਦੇ ਵਿਚਕਾਰ ਇੱਕ ਬੇਤਰਤੀਬ ਪੂਰਨ ਅੰਕ ਪ੍ਰਾਪਤ ਕਰੋ Get-random -maximum 100
ਇਸਲਈ, 0..1 ਲਈ ਸਾਨੂੰ ਅਧਿਕਤਮ ਐਲੀਮੈਂਟ ਨੰਬਰ = 0 ਦੇ ਨਾਲ ਸਾਈਜ਼ 2..1 ਸੈੱਟ ਕਰਨ ਦੀ ਲੋੜ ਹੈ।

7. ਆਉਣ ਵਾਲੇ ਸੁਨੇਹਿਆਂ ਦੀ ਪ੍ਰਕਿਰਿਆ ਅਤੇ ਵੱਧ ਤੋਂ ਵੱਧ ਕਤਾਰ ਦੀ ਲੰਬਾਈ

ਅਸੀਂ ਪਹਿਲਾਂ ਕਿੱਥੇ ਰੁਕੇ ਸੀ? ਸਾਡੇ ਕੋਲ $MyMessageGet ਵੇਰੀਏਬਲ ਹੈ
ਅਤੇ ਇਸ ਤੋਂ ਪ੍ਰਾਪਤ $Content4Pars01, ਜਿਸ ਵਿੱਚੋਂ ਅਸੀਂ Content4Pars01.result ਐਰੇ ਦੇ ਤੱਤਾਂ ਵਿੱਚ ਦਿਲਚਸਪੀ ਰੱਖਦੇ ਹਾਂ

$Content4Pars01.result[0].update_id
$Content4Pars01.result[0].message
$Content4Pars01.result[0].message.text

ਆਉ ਬੋਟ /message10, /message11, /message12, /word ਅਤੇ ਦੁਬਾਰਾ /word ਅਤੇ /hello ਭੇਜੀਏ।
ਆਓ ਦੇਖੀਏ ਕਿ ਸਾਨੂੰ ਕੀ ਮਿਲਿਆ:

$Content4Pars01.result[0].message.text
$Content4Pars01.result[2].message.text

ਆਓ ਪ੍ਰਾਪਤ ਕੀਤੀ ਹਰ ਚੀਜ਼ ਨੂੰ ਵੇਖੀਏ ਅਤੇ ਇੱਕ ਜਵਾਬ ਭੇਜੀਏ ਜੇਕਰ ਸੁਨੇਹਾ /ਸ਼ਬਦ ਸੀ
ਕੰਸਟਰੱਕਟ ਦਾ ਕੇਸ, ਜਿਸਨੂੰ ਕੁਝ ਲੋਕ if-elseif ਦੇ ਰੂਪ ਵਿੱਚ ਵਰਣਨ ਕਰਦੇ ਹਨ, ਨੂੰ ਪਾਵਰਸ਼ੇਲ ਵਿੱਚ ਕਿਹਾ ਜਾਂਦਾ ਹੈ ਸਵਿੱਚ ਦੁਆਰਾ. ਉਸੇ ਸਮੇਂ, ਹੇਠਾਂ ਦਿੱਤਾ ਕੋਡ -wildcard ਕੁੰਜੀ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ, ਜੋ ਕਿ ਪੂਰੀ ਤਰ੍ਹਾਂ ਬੇਲੋੜੀ ਅਤੇ ਨੁਕਸਾਨਦੇਹ ਵੀ ਹੈ।

ਕੁਝ ਕੋਡ #7.1

Write-Output "This is part 7"
Foreach ($Result in $Content4Pars01.result) # Да, можно сделать быстрее 
 { 
    switch -wildcard ($Result.message.text) 
            {
            "/word" {MyFirstFunction($TextForExample1)}
            }
}

ਚਲੋ ਸਕ੍ਰਿਪਟ ਨੂੰ ਇੱਕ ਦੋ ਵਾਰ ਚਲਾਉਂਦੇ ਹਾਂ। ਸਾਨੂੰ ਹਰੇਕ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਕੋਸ਼ਿਸ਼ ਲਈ ਦੋ ਵਾਰ ਇੱਕੋ ਸ਼ਬਦ ਮਿਲੇਗਾ, ਖਾਸ ਤੌਰ 'ਤੇ ਜੇਕਰ ਅਸੀਂ ਬੇਤਰਤੀਬੇ ਨੂੰ ਲਾਗੂ ਕਰਨ ਵਿੱਚ ਗਲਤੀ ਕੀਤੀ ਹੈ।

ਪਰ ਰੁਕੋ. ਅਸੀਂ /ਸ਼ਬਦ ਨੂੰ ਦੁਬਾਰਾ ਨਹੀਂ ਭੇਜਿਆ, ਤਾਂ ਫਿਰ ਸੁਨੇਹੇ ਦੀ ਦੁਬਾਰਾ ਪ੍ਰਕਿਰਿਆ ਕਿਉਂ ਕੀਤੀ ਜਾ ਰਹੀ ਹੈ?

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

ਇਹ ਬੇਸ਼ਕ ਦਸਤਾਵੇਜ਼ਾਂ ਵਿੱਚ ਵਰਣਨ ਕੀਤਾ ਗਿਆ ਹੈ, ਪਰ ਤੁਹਾਨੂੰ ਇਸਨੂੰ ਪੜ੍ਹਨਾ ਪਵੇਗਾ!

ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਸਾਨੂੰ ?chat_id ਪੈਰਾਮੀਟਰ, ਅਤੇ &timeout, &limit, &parse_mode=HTML ਅਤੇ &disable_web_page_preview=true ਦੀ ਅਜੇ ਲੋੜ ਨਹੀਂ ਹੈ।

ਲਈ ਦਸਤਾਵੇਜ਼ ਟੈਲੀਗ੍ਰਾਮ ਏਪੀਆਈ ਇੱਥੇ ਹੈ
ਇਹ ਚਿੱਟੇ ਅਤੇ ਅੰਗਰੇਜ਼ੀ ਵਿੱਚ ਕਹਿੰਦਾ ਹੈ:
ਵਾਪਸ ਕੀਤੇ ਜਾਣ ਵਾਲੇ ਪਹਿਲੇ ਅੱਪਡੇਟ ਦਾ ਪਛਾਣਕਰਤਾ। ਪਹਿਲਾਂ ਪ੍ਰਾਪਤ ਕੀਤੇ ਅੱਪਡੇਟਾਂ ਦੇ ਪਛਾਣਕਰਤਾਵਾਂ ਵਿੱਚੋਂ ਸਭ ਤੋਂ ਵੱਧ ਇੱਕ ਤੋਂ ਵੱਧ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ। ਪੂਰਵ-ਨਿਰਧਾਰਤ ਤੌਰ 'ਤੇ, ਅੱਪਡੇਟ ਜਲਦੀ ਤੋਂ ਜਲਦੀ ਸ਼ੁਰੂ ਹੁੰਦੇ ਹਨ
ਅਸਪਸ਼ਟ ਅੱਪਡੇਟ ਵਾਪਸ ਕਰ ਦਿੱਤੇ ਗਏ ਹਨ। ਜਿਵੇਂ ਹੀ getUpdates ਨੂੰ ਇੱਕ ਨਾਲ ਕਾਲ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਇੱਕ ਅਪਡੇਟ ਦੀ ਪੁਸ਼ਟੀ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਆਫਸੈੱਟ ਵੱਧ ਇਸ ਦੇ update_id ਨਾਲੋਂ. ਨੈਗੇਟਿਵ ਆਫਸੈੱਟ ਨੂੰ ਅੱਪਡੇਟ ਕਤਾਰ ਦੇ ਅੰਤ ਤੋਂ -offset ਅੱਪਡੇਟ ਤੋਂ ਸ਼ੁਰੂ ਹੋਣ ਵਾਲੇ ਅੱਪਡੇਟਾਂ ਨੂੰ ਮੁੜ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਨਿਰਧਾਰਿਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਪਿਛਲੇ ਸਾਰੇ ਅੱਪਡੇਟ ਭੁੱਲ ਜਾਣਗੇ।

ਆਓ ਦੇਖੀਏ:

$Content4Pars01.result[0].update_id
$Content4Pars01.result[1].update_id 
$Content4Pars01.result | select -last 1
($Content4Pars01.result | select -last 1).update_id

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

ਪਹਿਲਾਂ, ਸਾਡੀ "ਸਾਰੇ ਸੁਨੇਹੇ" ਪੁੱਛਗਿੱਛ ਸਤਰ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦਿੰਦੀ ਸੀ

$URLGET = "https://api.telegram.org/bot$MyToken/getUpdates"

ਅਤੇ ਇਹ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦੇਵੇਗਾ

$LastMessageId = ($Content4Pars01.result | select -last 1).update_id
$URLGET1 = "https://api.telegram.org/bot$mytoken/getUpdates?offset=$LastMessageId&limit=100" 
$MyMessageGet = Invoke-WebRequest -Uri $URLGET1 -Method Get -Proxy $MyProxy 

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

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

ਕੋਡ ਦੀਆਂ ਕੁਝ ਹੋਰ ਲਾਈਨਾਂ

$LastMessageId = ($Content4Pars01.result | select -last 1).update_id  #ошибку в этом месте предполагается исправить самостоятельно. 
$URLGET1 = "https://api.telegram.org/bot$mytoken/getUpdates?offset=$LastMessageId&limit=100" 
Invoke-WebRequest -Uri $URLGET1 -Method Get -Proxy $MyProxy

8. ਸਿੱਟੇ ਦੀ ਬਜਾਏ

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

ਕਰਨ ਲਈ ਸਿਰਫ਼ ਚਾਰ ਚੀਜ਼ਾਂ ਬਾਕੀ ਹਨ:

• ਚੈਟ ਵਿੱਚ ਇੱਕ ਬੇਨਤੀ ਦਾ ਸਹੀ ਜਵਾਬ ਭੇਜਣਾ
• ਕਿਸੇ ਵੀ ਚੈਟ ਦਾ ਜਵਾਬ ਭੇਜਣਾ ਜਿਸ ਵਿੱਚ ਬੋਟ ਸ਼ਾਮਲ ਕੀਤਾ ਗਿਆ ਸੀ
• ਇੱਕ ਲੂਪ ਵਿੱਚ ਕੋਡ ਨੂੰ ਚਲਾਉਣਾ
• ਵਿੰਡੋਜ਼ ਸ਼ਡਿਊਲਰ ਤੋਂ ਇੱਕ ਬੋਟ ਲਾਂਚ ਕਰਨਾ।

ਇਹ ਸਾਰੇ ਕੰਮ ਸਧਾਰਨ ਹਨ ਅਤੇ ਪੈਰਾਮੀਟਰਾਂ ਬਾਰੇ ਦਸਤਾਵੇਜ਼ਾਂ ਨੂੰ ਪੜ੍ਹ ਕੇ ਆਸਾਨੀ ਨਾਲ ਪੂਰਾ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ ਜਿਵੇਂ ਕਿ
ਸੈਟ-ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਪਾਲਿਸੀ ਅਪ੍ਰਬੰਧਿਤ ਅਤੇ -ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਪਾਲਿਸੀ ਬਾਈਪਾਸ
ਫਾਰਮ ਦਾ ਚੱਕਰ

$TimeToSleep = 3 # опрос каждые 3 секунды
$TimeToWork = 10 # минут
$HowManyTimes = $TimeToWork*60/$TimeToSleep # счетчик для цикла
$MainCounter = 0
for ($MainCounter=0; $MainCounter -le $HowManyTimes) {
sleep $TimeToSleep
$MainCounter ++

ਪੜ੍ਹਨ ਵਾਲੇ ਹਰ ਕਿਸੇ ਦਾ ਧੰਨਵਾਦ.

ਸਰੋਤ: www.habr.com