ಪ್ರೊಹೋಸ್ಟರ್ > Блог > ಇಂಟರ್ನೆಟ್ ಸುದ್ದಿ > ಪವರ್‌ಶೆಲ್‌ನಲ್ಲಿ 7-9 ತರಗತಿಗಳಲ್ಲಿ ಶಾಲಾ ಮಕ್ಕಳಿಗೆ ಸರಳವಾದ ಟೆಲಿಗ್ರಾಮ್ ಬೋಟ್‌ನ ಟೆಂಪ್ಲೇಟ್

ಪವರ್‌ಶೆಲ್‌ನಲ್ಲಿ 7-9 ತರಗತಿಗಳಲ್ಲಿ ಶಾಲಾ ಮಕ್ಕಳಿಗೆ ಸರಳವಾದ ಟೆಲಿಗ್ರಾಮ್ ಬೋಟ್‌ನ ಟೆಂಪ್ಲೇಟ್

ಸ್ನೇಹಿತರೊಂದಿಗಿನ ಸಂಭಾಷಣೆಯ ಸಮಯದಲ್ಲಿ, ಅವರ ಶಾಲೆಯಲ್ಲಿ 8-10 ನೇ ತರಗತಿಯ ಮಕ್ಕಳಿಗೆ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಅನ್ನು ಕಲಿಸಲಾಗುವುದಿಲ್ಲ ಎಂದು ನಾನು ಇದ್ದಕ್ಕಿದ್ದಂತೆ ಕಲಿತಿದ್ದೇನೆ. ವರ್ಡ್, ಎಕ್ಸೆಲ್ ಮತ್ತು ಎಲ್ಲವೂ. ಲೋಗೋ ಇಲ್ಲ, ಪಾಸ್ಕಲ್ ಅಲ್ಲ, ಎಕ್ಸೆಲ್‌ಗಾಗಿ ವಿಬಿಎ ಕೂಡ ಅಲ್ಲ.

ನನಗೆ ತುಂಬಾ ಆಶ್ಚರ್ಯವಾಯಿತು, ಇಂಟರ್ನೆಟ್ ತೆರೆದು ಓದಲು ಪ್ರಾರಂಭಿಸಿದೆ -
ಹೊಸ ಪೀಳಿಗೆಯ ಶಿಕ್ಷಣವನ್ನು ಉತ್ತೇಜಿಸುವುದು ವಿಶೇಷ ಶಾಲೆಯ ಕಾರ್ಯಗಳಲ್ಲಿ ಒಂದಾಗಿದೆ, ಅದು ಅದರ ಅಭಿವೃದ್ಧಿ ಮತ್ತು ಜೀವನಶೈಲಿಯ ಮಟ್ಟದಲ್ಲಿ ಮಾಹಿತಿ ಸಮಾಜದ ಪರಿಸ್ಥಿತಿಗಳನ್ನು ಪೂರೈಸುತ್ತದೆ.
ಈ ಕೋರ್ಸ್ ವಿದ್ಯಾರ್ಥಿಗಳಿಗೆ ಪಾಸ್ಕಲ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಯ ಮೂಲಭೂತ ರಚನೆಗಳ ಬಗ್ಗೆ ತಮ್ಮ ಜ್ಞಾನವನ್ನು ಅಭ್ಯಾಸದಲ್ಲಿ ಕ್ರೋಢೀಕರಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. (2017 ರ ಕೆಲವು ಜಿಮ್ನಾಷಿಯಂನ ಕಾರ್ಯಕ್ರಮದಿಂದ)

ಕೊನೆಯಲ್ಲಿ, ನಾನು ಒಂದೆರಡು ಗಂಟೆಗಳ ಕಾಲ ಕಳೆಯಲು ನಿರ್ಧರಿಸಿದೆ ಮತ್ತು "ಶಾಲಾ ಮಕ್ಕಳಿಗೆ ಸರಳವಾದ ಬೋಟ್ ಅನ್ನು ಹೇಗೆ ರಚಿಸುವುದು" ಎಂಬ ಉದಾಹರಣೆಯನ್ನು ಚಿತ್ರಿಸಲು ನಿರ್ಧರಿಸಿದೆ.

ಪವರ್‌ಶೆಲ್‌ನಲ್ಲಿ ಮತ್ತೊಂದು ಸರಳ ಬೋಟ್ ಅನ್ನು ಹೇಗೆ ಬರೆಯುವುದು ಮತ್ತು ವೆಬ್‌ಹೂಕ್, ವೈಟ್ ಐಪಿಗಳು, ಮೀಸಲಾದ ಸರ್ವರ್‌ಗಳು, ಕ್ಲೌಡ್‌ನಲ್ಲಿ ನಿಯೋಜಿಸಲಾದ ವರ್ಚುವಲ್ ಯಂತ್ರಗಳು ಮತ್ತು ಹೀಗೆ - ಸಾಮಾನ್ಯ ವಿಂಡೋಸ್‌ನೊಂದಿಗೆ ಸಾಮಾನ್ಯ ಹೋಮ್ ಪಿಸಿಯಲ್ಲಿ ಅದನ್ನು ಹೇಗೆ ಕೆಲಸ ಮಾಡುವುದು ಎಂಬುದನ್ನು ಕಟ್ ಕೆಳಗೆ ನೀಡಲಾಗಿದೆ.

TLDR: ವ್ಯಾಕರಣ ಮತ್ತು ವಾಸ್ತವಿಕ ದೋಷಗಳೊಂದಿಗೆ ಮತ್ತೊಂದು ನೀರಸ ಲೇಖನ, ಓದಲು ಏನೂ ಇಲ್ಲ, ಹಾಸ್ಯವಿಲ್ಲ, ಚಿತ್ರಗಳಿಲ್ಲ.

ಲೇಖನದಲ್ಲಿ ಹೊಸದೇನೂ ಇಲ್ಲ, ಮೊದಲು ಬರೆದ ಬಹುತೇಕ ಎಲ್ಲವೂ ಈಗಾಗಲೇ ಹಬ್ರೆಯಲ್ಲಿವೆ, ಉದಾಹರಣೆಗೆ ಲೇಖನಗಳಲ್ಲಿ ಸೂಚನೆಗಳು: ಟೆಲಿಗ್ರಾಮ್‌ನಲ್ಲಿ ಬಾಟ್‌ಗಳನ್ನು ಹೇಗೆ ರಚಿಸುವುದು и ಸಿಸ್ಟಮ್ ಅಡ್ಮಿನಿಸ್ಟ್ರೇಟರ್ಗಾಗಿ ಟೆಲಿಗ್ರಾಮ್ ಬೋಟ್.
ಇದಲ್ಲದೆ, ಪ್ರತಿ ಬಾರಿ ಶೈಕ್ಷಣಿಕ ಸಾಹಿತ್ಯವನ್ನು ಉಲ್ಲೇಖಿಸದಿರಲು ಲೇಖನವು ಉದ್ದೇಶಪೂರ್ವಕವಾಗಿ ಅನಗತ್ಯವಾಗಿದೆ. ಪಠ್ಯದಲ್ಲಿ ಗ್ಯಾಂಗ್ 4, ಪವರ್‌ಶೆಲ್ ಡೀಪ್ ಡೈವ್ಸ್ ಅಥವಾ AWS ವೆಲ್-ಆರ್ಕಿಟೆಕ್ಟೆಡ್ ಫ್ರೇಮ್‌ವರ್ಕ್‌ನ 5 ಪಿಲ್ಲರ್‌ಗಳ ಬಗ್ಗೆ ಯಾವುದೇ ಉಲ್ಲೇಖಗಳಿಲ್ಲ.

ಮುನ್ನುಡಿಯ ಬದಲಿಗೆ, ನೀವು ಬಿಟ್ಟುಬಿಡಬಹುದು

ಸ್ಕಿಪ್ ಮಾಡಲು ಹಿಂಜರಿಯಬೇಡಿ2006 ರಲ್ಲಿ, ಮೈಕ್ರೋಸಾಫ್ಟ್ ಪವರ್‌ಶೆಲ್ 1.0 ಅನ್ನು ಆಗಿನ-ವಿಂಡೋಸ್ ಎಕ್ಸ್‌ಪಿ, ವಿಸ್ಟಾ ಮತ್ತು ಸರ್ವರ್ 2003 ಗಾಗಿ ಬಿಡುಗಡೆ ಮಾಡಿತು. ಕೆಲವು ರೀತಿಯಲ್ಲಿ, ಇದು cmdbat ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳು, vb ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳು, ವಿಂಡೋಸ್ ಸ್ಕ್ರಿಪ್ಟ್ ಹೋಸ್ಟ್ ಮತ್ತು JScript ನಂತಹ ವಿಷಯಗಳನ್ನು ಬದಲಾಯಿಸಿತು.

ಈಗಲೂ ಸಹ, ಲೂಪ್‌ಗಳು, ತರಗತಿಗಳು, ಕಾರ್ಯಗಳು, MS GUI ಕರೆಗಳ ಉಪಸ್ಥಿತಿಯ ಹೊರತಾಗಿಯೂ, ಬಹುಶಃ ಇನ್ನೂ ಬಳಸಿದ ಡೆಲ್ಫಿ (ಅಥವಾ ಯಾವುದಾದರೂ ಹಳೆಯದು) ಬದಲಿಗೆ ಲೋಗೋ ಆಯ್ಕೆಗಳ ನಂತರ ಪವರ್‌ಶೆಲ್ ಅನ್ನು ಮುಂದಿನ ಹಂತವೆಂದು ಪರಿಗಣಿಸಬಹುದು, Git ಏಕೀಕರಣ ಹೀಗೆ.

ಪವರ್‌ಶೆಲ್ ಅನ್ನು ತುಲನಾತ್ಮಕವಾಗಿ ವಿರಳವಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ; ನೀವು ಅದನ್ನು ಪವರ್‌ಶೆಲ್ ಕೋರ್, ವಿಎಂವೇರ್ ವಿಸ್ಪಿಯರ್ ಪವರ್‌ಸಿಎಲ್‌ಐ, ಅಜುರೆ ಪವರ್‌ಶೆಲ್, ಎಂಎಸ್ ಎಕ್ಸ್‌ಚೇಂಜ್, ಅಪೇಕ್ಷಿತ ಸ್ಟೇಟ್ ಕಾನ್ಫಿಗರೇಶನ್ ರೂಪದಲ್ಲಿ ಮಾತ್ರ ಎದುರಿಸಬಹುದು. ಪವರ್‌ಶೆಲ್ ವೆಬ್ ಪ್ರವೇಶ ಮತ್ತು ಒಂದು ಡಜನ್ ಅಥವಾ ಹೆಚ್ಚು ಅಪರೂಪವಾಗಿ ಬಳಸುವ ಕಾರ್ಯಕ್ರಮಗಳು ಮತ್ತು ಕಾರ್ಯಗಳು. ಬಹುಶಃ ಅವರು ಬಿಡುಗಡೆಯೊಂದಿಗೆ ಎರಡನೇ ಗಾಳಿಯನ್ನು ಪಡೆಯುತ್ತಾರೆ WSL2, ಆದರೆ ಇದು ನಿಖರವಾಗಿ ಅಲ್ಲ.

ಪವರ್‌ಶೆಲ್ ಮೂರು ದೊಡ್ಡ ಪ್ರಯೋಜನಗಳನ್ನು ಹೊಂದಿದೆ:

  1. ಇದು ತುಲನಾತ್ಮಕವಾಗಿ ಸರಳವಾಗಿದೆ, ಅದರ ಬಗ್ಗೆ ಸಾಕಷ್ಟು ಸಾಹಿತ್ಯ ಮತ್ತು ಉದಾಹರಣೆಗಳಿವೆ, ಮತ್ತು ರಷ್ಯನ್ ಭಾಷೆಯಲ್ಲಿಯೂ ಸಹ, ಉದಾಹರಣೆಗೆ, ಫೋರ್ಚ್ ಬಗ್ಗೆ ಒಂದು ಲೇಖನ - ಪುಸ್ತಕದಿಂದ ಆಳದಲ್ಲಿ ಪವರ್ಶೆಲ್ - ವ್ಯತ್ಯಾಸದ ಬಗ್ಗೆ () ಮತ್ತು {}
  2. ಅವರು ಸಂಪಾದಕರೊಂದಿಗೆ ಹೋಗುತ್ತಾರೆ ISE, ವಿಂಡೋಸ್‌ನೊಂದಿಗೆ ಸೇರಿಸಲಾಗಿದೆ. ಅಲ್ಲಿ ಕೆಲವು ರೀತಿಯ ಡೀಬಗರ್ ಕೂಡ ಇದೆ.
  3. ಅದರಿಂದ ಕರೆ ಮಾಡುವುದು ಸುಲಭ ಚಿತ್ರಾತ್ಮಕ ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ನಿರ್ಮಿಸಲು ಘಟಕಗಳು.

0. ತಯಾರಿ.

ನಮಗೆ ಅಗತ್ಯವಿದೆ:

  • ವಿಂಡೋಸ್ ಪಿಸಿ (ನನ್ನ ಬಳಿ ವಿಂಡೋಸ್ 10 ಇದೆ)
  • ಕನಿಷ್ಠ ಕೆಲವು ರೀತಿಯ ಇಂಟರ್ನೆಟ್ ಪ್ರವೇಶ (ಉದಾಹರಣೆಗೆ NAT ಮೂಲಕ)
  • ಟೆಲಿಗ್ರಾಮ್‌ಗೆ ಸೀಮಿತ ಪ್ರವೇಶವನ್ನು ಹೊಂದಿರುವವರಿಗೆ - ಬ್ರೌಸರ್‌ನಲ್ಲಿ ಫ್ರೀಗೇಟ್ ಅನ್ನು ಸ್ಥಾಪಿಸಿ ಮತ್ತು ಕಾನ್ಫಿಗರ್ ಮಾಡಲಾಗಿದೆ, ಕೆಲವು ಕಷ್ಟಕರ ಸಂದರ್ಭಗಳಲ್ಲಿ, ಸಿಂಪಲ್ DNS ಕ್ರಿಪ್ಟ್ ಜೊತೆಗೆ
  • ನಿಮ್ಮ ಫೋನ್‌ನಲ್ಲಿ ಟೆಲಿಗ್ರಾಮ್ ಕ್ಲೈಂಟ್ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಿದೆ
  • ಮೂಲಭೂತ ಅಂಶಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು - ವೇರಿಯೇಬಲ್, ಅರೇ, ಲೂಪ್ ಎಂದರೇನು.

ಲೇಖನಗಳನ್ನು ತೆರೆಯಲಾಗಿದೆ ಮತ್ತು ಓದಿದೆ - ಸೂಚನೆಗಳು: ಟೆಲಿಗ್ರಾಮ್‌ನಲ್ಲಿ ಬಾಟ್‌ಗಳನ್ನು ಹೇಗೆ ರಚಿಸುವುದು и ಸಿಸ್ಟಮ್ ಅಡ್ಮಿನಿಸ್ಟ್ರೇಟರ್ಗಾಗಿ ಟೆಲಿಗ್ರಾಮ್ ಬೋಟ್

1. ಇನ್ನೊಂದು ಪರೀಕ್ಷಾ ಬೋಟ್ ಅನ್ನು ರಚಿಸೋಣ.

ಪ್ರತಿಯೊಬ್ಬರೂ ಇದನ್ನು ಈಗಾಗಲೇ ತಿಳಿದಿರುವ ಕಾರಣ ಮತ್ತು ಈಗಾಗಲೇ ಸಂಭವಿಸಿರುವುದರಿಂದ, ನೀವು ಅದನ್ನು ಬಿಟ್ಟುಬಿಡಬಹುದುಮೇಲಿನ ಲೇಖನದಲ್ಲಿ ಹೇಳಿದಂತೆ - ಮೊದಲನೆಯದಾಗಿ, ಟೆಲಿಗ್ರಾಮ್‌ಗಾಗಿ ಬೋಟ್ - ಇದು ಇನ್ನೂ ನಿಮ್ಮ ಭಾಗದಲ್ಲಿ ಚಾಲನೆಯಲ್ಲಿರುವ ಅಪ್ಲಿಕೇಶನ್ ಆಗಿದೆ ಮತ್ತು ಟೆಲಿಗ್ರಾಮ್ ಬಾಟ್ API ಗೆ ವಿನಂತಿಗಳನ್ನು ಮಾಡುತ್ತದೆ. ಇದಲ್ಲದೆ, API ಸ್ಪಷ್ಟವಾಗಿದೆ - ಬೋಟ್ ನಿರ್ದಿಷ್ಟ URL ಅನ್ನು ನಿಯತಾಂಕಗಳೊಂದಿಗೆ ಪ್ರವೇಶಿಸುತ್ತದೆ ಮತ್ತು ಟೆಲಿಗ್ರಾಮ್ JSON ವಸ್ತುವಿನೊಂದಿಗೆ ಪ್ರತಿಕ್ರಿಯಿಸುತ್ತದೆ.

ಸಂಬಂಧಿತ ಸಮಸ್ಯೆಗಳು: ಕೆಲವು ಅಜ್ಞಾತ ರೀತಿಯಲ್ಲಿ ನೀವು JSON ಆಬ್ಜೆಕ್ಟ್‌ನಿಂದ ಕೆಲವು ಕೋಡ್ ಅನ್ನು ತೆಗೆದುಕೊಂಡರೆ ಮತ್ತು ಅದನ್ನು ಹೇಗಾದರೂ ಕಾರ್ಯಗತಗೊಳಿಸಲು ಕಳುಹಿಸಿದರೆ (ಉದ್ದೇಶಪೂರ್ವಕವಾಗಿ ಅಲ್ಲ), ಕೋಡ್ ಅನ್ನು ನಿಮಗಾಗಿ ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ.

ರಚನೆಯ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಮೇಲಿನ ಎರಡು ಲೇಖನಗಳಲ್ಲಿ ವಿವರಿಸಲಾಗಿದೆ, ಆದರೆ ನಾನು ಪುನರಾವರ್ತಿಸುತ್ತೇನೆ: ಟೆಲಿಗ್ರಾಮ್‌ನಲ್ಲಿ ನಾವು ಸಂಪರ್ಕಗಳನ್ನು ತೆರೆಯುತ್ತೇವೆ, @botfather ಅನ್ನು ನೋಡಿ, ಅವನಿಗೆ /ಹೊಸಬಾಟ್ ಎಂದು ಹೇಳಿ, Botfortest12344321 ಬೋಟ್ ಅನ್ನು ರಚಿಸಿ, ಅದನ್ನು Mynext1234bot ಎಂದು ಕರೆ ಮಾಡಿ ಮತ್ತು ಅದರ ವಿಶಿಷ್ಟ ಕೀಲಿಯೊಂದಿಗೆ ಸಂದೇಶವನ್ನು ಸ್ವೀಕರಿಸಿ ರೂಪ 1234544311:AbcDefNNNNNNNNNNNNNN

ಕೀಲಿಯನ್ನು ನೋಡಿಕೊಳ್ಳಿ ಮತ್ತು ಅದನ್ನು ಬಿಟ್ಟುಕೊಡಬೇಡಿ!

ನಂತರ ನೀವು ಬೋಟ್ ಅನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡಬಹುದು, ಉದಾಹರಣೆಗೆ, ಅದನ್ನು ಗುಂಪುಗಳಿಗೆ ಸೇರಿಸುವುದನ್ನು ನಿಷೇಧಿಸಿ, ಆದರೆ ಮೊದಲ ಹಂತಗಳಲ್ಲಿ ಇದು ಅನಿವಾರ್ಯವಲ್ಲ.

"/mybot" ಗಾಗಿ BotFather ಅನ್ನು ಕೇಳೋಣ ಮತ್ತು ನಮಗೆ ಏನಾದರೂ ಇಷ್ಟವಾಗದಿದ್ದರೆ ಸೆಟ್ಟಿಂಗ್‌ಗಳನ್ನು ಹೊಂದಿಸಿ.

ಮತ್ತೆ ಸಂಪರ್ಕಗಳನ್ನು ತೆರೆಯೋಣ, ಅಲ್ಲಿ @Botfortest12344321 ಅನ್ನು ಹುಡುಕಿ (@ ನೊಂದಿಗೆ ಹುಡುಕಾಟವನ್ನು ಪ್ರಾರಂಭಿಸುವುದು ಕಡ್ಡಾಯವಾಗಿದೆ), "ಪ್ರಾರಂಭ" ಕ್ಲಿಕ್ ಮಾಡಿ ಮತ್ತು "/ ರೋಬೋಟ್‌ಗಳಿಗೆ ಗ್ಲೋರಿ" ಬೋಟ್‌ಗೆ ಬರೆಯಿರಿ. / ಚಿಹ್ನೆ ಅಗತ್ಯವಿದೆ, ಉಲ್ಲೇಖಗಳು ಅಗತ್ಯವಿಲ್ಲ.
ಬೋಟ್, ಸಹಜವಾಗಿ, ಯಾವುದಕ್ಕೂ ಉತ್ತರಿಸುವುದಿಲ್ಲ.

ಬೋಟ್ ಅನ್ನು ರಚಿಸಲಾಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸೋಣ ಮತ್ತು ಅದನ್ನು ತೆರೆಯೋಣ.

api.telegram.org/bot1234544311:AbcDefNNNNNNNNNNNNN/getMe
ಅಲ್ಲಿ 1234544311:AbcDefNNNNNNNNNNNNNN ಹಿಂದೆ ಸ್ವೀಕರಿಸಿದ ಕೀ,
ಮತ್ತು ಒಂದು ಸಾಲನ್ನು ಪಡೆಯಿರಿ
{"ಸರಿ":ನಿಜ,"ಫಲಿತಾಂಶ":{""}}

ನಾವು ಮೊದಲ ರಹಸ್ಯ ನುಡಿಗಟ್ಟು (ಟೋಕನ್) ಅನ್ನು ಹೊಂದಿದ್ದೇವೆ. ಈಗ ನಾವು ಎರಡನೇ ರಹಸ್ಯ ಸಂಖ್ಯೆಯನ್ನು ಕಂಡುಹಿಡಿಯಬೇಕು - ಬೋಟ್ನೊಂದಿಗೆ ಚಾಟ್ನ ID. ಪ್ರತಿಯೊಂದು ಚಾಟ್, ಗುಂಪು, ಇತ್ಯಾದಿಗಳು ವೈಯಕ್ತಿಕ ಮತ್ತು ತನ್ನದೇ ಆದ ಸಂಖ್ಯೆಯನ್ನು ಹೊಂದಿದೆ (ಕೆಲವೊಮ್ಮೆ ಮೈನಸ್ನೊಂದಿಗೆ - ತೆರೆದ ಗುಂಪುಗಳಿಗೆ). ಈ ಸಂಖ್ಯೆಯನ್ನು ಕಂಡುಹಿಡಿಯಲು, ನಾವು ಬ್ರೌಸರ್‌ನಲ್ಲಿ ವಿನಂತಿಸಬೇಕಾಗಿದೆ (ವಾಸ್ತವವಾಗಿ, ಇದು ಬ್ರೌಸರ್‌ನಲ್ಲಿ ಅಗತ್ಯವಿಲ್ಲ, ಆದರೆ ಉತ್ತಮ ತಿಳುವಳಿಕೆಗಾಗಿ ನೀವು ಅದರೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸಬಹುದು) ವಿಳಾಸ (ಅಲ್ಲಿ 1234544311:NNNNNNNNNN ನಿಮ್ಮ ಟೋಕನ್ ಆಗಿದೆ

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

ಮತ್ತು ಅಂತಹ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಪಡೆಯಿರಿ

{"ok":true,"result":[{"update_id":...,... ಚಾಟ್":{"id":123456789

ನಮಗೆ chat_id ಅಗತ್ಯವಿದೆ.

ನಾವು ಹಸ್ತಚಾಲಿತವಾಗಿ ಚಾಟ್‌ಗೆ ಬರೆಯಬಹುದೇ ಎಂದು ಪರಿಶೀಲಿಸೋಣ: ಬ್ರೌಸರ್‌ನಿಂದ ವಿಳಾಸವನ್ನು ಕರೆ ಮಾಡಿ

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

ನಿಮ್ಮ ಚಾಟ್‌ನಲ್ಲಿ ಬೋಟ್‌ನಿಂದ ನೀವು ಸಂದೇಶವನ್ನು ಸ್ವೀಕರಿಸಿದರೆ, ಸರಿ, ನೀವು ಮುಂದಿನ ಹಂತಕ್ಕೆ ಮುಂದುವರಿಯಿರಿ.

ಈ ರೀತಿಯಲ್ಲಿ (ಬ್ರೌಸರ್ ಮೂಲಕ) ನೀವು ಯಾವಾಗಲೂ ಲಿಂಕ್ ಉತ್ಪಾದನೆಯಲ್ಲಿ ಸಮಸ್ಯೆಗಳಿವೆಯೇ ಅಥವಾ ಎಲ್ಲೋ ಮರೆಮಾಡಲಾಗಿದೆ ಮತ್ತು ಕೆಲಸ ಮಾಡದಿದ್ದರೆ ನೀವು ಯಾವಾಗಲೂ ಪರಿಶೀಲಿಸಬಹುದು.

ಓದುವುದನ್ನು ಮುಂದುವರಿಸುವ ಮೊದಲು ನೀವು ತಿಳಿದುಕೊಳ್ಳಬೇಕಾದದ್ದು

ಟೆಲಿಗ್ರಾಮ್ ಹಲವಾರು ರೀತಿಯ ಗುಂಪು ಚಾಟ್‌ಗಳನ್ನು ಹೊಂದಿದೆ (ತೆರೆದ, ಮುಚ್ಚಲಾಗಿದೆ). ಈ ಚಾಟ್‌ಗಳಿಗಾಗಿ, ಕೆಲವು ಕಾರ್ಯಗಳು (ಉದಾಹರಣೆಗೆ, ಐಡಿ) ವಿಭಿನ್ನವಾಗಿವೆ, ಇದು ಕೆಲವೊಮ್ಮೆ ಕೆಲವು ಸಮಸ್ಯೆಗಳನ್ನು ಉಂಟುಮಾಡುತ್ತದೆ.

ಇದು 2019 ರ ಅಂತ್ಯ ಎಂದು ಭಾವಿಸೋಣ ಮತ್ತು ನಮ್ಮ ಕಾಲದ ನಾಯಕ, ಪ್ರಸಿದ್ಧ ಮ್ಯಾನ್-ಆರ್ಕೆಸ್ಟ್ರಾ (ನಿರ್ವಾಹಕರು, ವಕೀಲರು, ಮಾಹಿತಿ ಭದ್ರತಾ ತಜ್ಞರು, ಪ್ರೋಗ್ರಾಮರ್ ಮತ್ತು ಪ್ರಾಯೋಗಿಕವಾಗಿ MVP) Evgeniy V. $i ವೇರಿಯೇಬಲ್ ಅನ್ನು ಒಂದು ಶ್ರೇಣಿಯಿಂದ ಪ್ರತ್ಯೇಕಿಸುತ್ತದೆ, ಕುಣಿಕೆಗಳನ್ನು ಮಾಸ್ಟರಿಂಗ್ ಮಾಡಿದೆ, ಮುಂದಿನ ಒಂದೆರಡು ವರ್ಷಗಳಲ್ಲಿ ನೋಡಿ ಚಾಕೊಲೇಟಿಯನ್ನು ಕರಗತ ಮಾಡಿಕೊಳ್ಳಿ, ಮತ್ತು ಪವರ್‌ಶೆಲ್‌ನೊಂದಿಗೆ ಸಮಾನಾಂತರ ಪ್ರಕ್ರಿಯೆ и ಪ್ರತಿ ವಸ್ತುವಿಗೆ ಸಮಾನಾಂತರ ಅದು ಬರುತ್ತದೆ.

1. ನಮ್ಮ ಬೋಟ್ ಏನು ಮಾಡುತ್ತದೆ ಎಂಬುದರ ಕುರಿತು ನಾವು ಯೋಚಿಸುತ್ತೇವೆ

ನನಗೆ ಯಾವುದೇ ಆಲೋಚನೆಗಳು ಇರಲಿಲ್ಲ, ನಾನು ಯೋಚಿಸಬೇಕಾಗಿತ್ತು. ನಾನು ಈಗಾಗಲೇ ಬೋಟ್-ನೋಟ್‌ಬುಕ್ ಅನ್ನು ಬರೆದಿದ್ದೇನೆ. "ಎಲ್ಲೋ ಏನನ್ನಾದರೂ ಕಳುಹಿಸುವ" ಬೋಟ್ ಮಾಡಲು ನಾನು ಬಯಸಲಿಲ್ಲ. Azure ಗೆ ಸಂಪರ್ಕಿಸಲು ನಿಮಗೆ ಕ್ರೆಡಿಟ್ ಕಾರ್ಡ್ ಅಗತ್ಯವಿದೆ, ಆದರೆ ವಿದ್ಯಾರ್ಥಿ ಅದನ್ನು ಎಲ್ಲಿಂದ ಪಡೆಯುತ್ತಾನೆ? ಎಲ್ಲವೂ ಅಷ್ಟು ಕೆಟ್ಟದ್ದಲ್ಲ ಎಂದು ಗಮನಿಸಬೇಕು: ಮುಖ್ಯ ಮೋಡಗಳು ಕೆಲವು ರೀತಿಯ ಪರೀಕ್ಷಾ ಅವಧಿಯನ್ನು ಉಚಿತವಾಗಿ ನೀಡುತ್ತವೆ (ಆದರೆ ನಿಮಗೆ ಇನ್ನೂ ಕ್ರೆಡಿಟ್ ಕಾರ್ಡ್ ಸಂಖ್ಯೆ ಬೇಕು - ಮತ್ತು ಅದರಿಂದ ಡಾಲರ್ ಡೆಬಿಟ್ ಆಗುತ್ತದೆ ಎಂದು ತೋರುತ್ತದೆ. ನನಗೆ ನೆನಪಿಲ್ಲ ಅದನ್ನು ನಂತರ ಹಿಂತಿರುಗಿಸಲಾಯಿತು.)

AI ML ಇಲ್ಲದೆ ಬೋಟ್-ಕಳಪೆ-ಕವಿ-ನೇಯ್ಗೆ ಮಾಡಲು ತುಂಬಾ ಆಸಕ್ತಿದಾಯಕವಲ್ಲ.

ನಿಘಂಟಿನಿಂದ ಇಂಗ್ಲಿಷ್ ಪದಗಳನ್ನು ನನಗೆ ನೆನಪಿಸುವ (ಅಥವಾ ನನಗೆ ಅಲ್ಲ) ಬೋಟ್ ಮಾಡಲು ನಾನು ನಿರ್ಧರಿಸಿದೆ.
ಡೇಟಾಬೇಸ್‌ನೊಂದಿಗೆ ಫಿಡ್ಲಿಂಗ್ ಮಾಡುವುದನ್ನು ತಪ್ಪಿಸಲು, ನಿಘಂಟನ್ನು ಪಠ್ಯ ಫೈಲ್‌ನಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಹಸ್ತಚಾಲಿತವಾಗಿ ನವೀಕರಿಸಲಾಗುತ್ತದೆ.
ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಕಾರ್ಯವು ಕೆಲಸದ ಮೂಲಭೂತ ಅಂಶಗಳನ್ನು ತೋರಿಸುವುದು, ಮತ್ತು ಕನಿಷ್ಠ ಭಾಗಶಃ ಸಿದ್ಧಪಡಿಸಿದ ಉತ್ಪನ್ನವನ್ನು ಮಾಡಬಾರದು.

2. ಮೊದಲ ಬಾರಿಗೆ ಏನು ಮತ್ತು ಹೇಗೆ ಪ್ರಯತ್ನಿಸಲಾಗುತ್ತಿದೆ

C:poshtranslate ಫೋಲ್ಡರ್ ಅನ್ನು ರಚಿಸೋಣ
ಮೊದಲಿಗೆ, ನಾವು ಯಾವ ರೀತಿಯ ಪವರ್‌ಶೆಲ್ ಅನ್ನು ಹೊಂದಿದ್ದೇವೆ ಎಂದು ನೋಡೋಣ, ಸ್ಟಾರ್ಟ್-ರನ್ ಮೂಲಕ ISE ಅನ್ನು ಪ್ರಾರಂಭಿಸೋಣ
ಪವರ್ಶೆಲ್ ಆಗಿದೆ
ಅಥವಾ ಸ್ಥಾಪಿಸಲಾದ ಪ್ರೋಗ್ರಾಂಗಳಲ್ಲಿ ಪವರ್‌ಶೆಲ್ ISE ಅನ್ನು ಹುಡುಕಿ.
ಪ್ರಾರಂಭದ ನಂತರ, ಸಾಮಾನ್ಯ ಪರಿಚಿತ "ಕೆಲವು ರೀತಿಯ ಸಂಪಾದಕ" ತೆರೆಯುತ್ತದೆ; ಯಾವುದೇ ಪಠ್ಯ ಕ್ಷೇತ್ರವಿಲ್ಲದಿದ್ದರೆ, ನೀವು ಯಾವಾಗಲೂ "ಫೈಲ್ - ಹೊಸದನ್ನು ರಚಿಸಿ" ಕ್ಲಿಕ್ ಮಾಡಬಹುದು.

ಪವರ್‌ಶೆಲ್‌ನ ಆವೃತ್ತಿಯನ್ನು ನೋಡೋಣ - ಪಠ್ಯ ಕ್ಷೇತ್ರದಲ್ಲಿ ಬರೆಯಿರಿ:

get-host

ಮತ್ತು F5 ಒತ್ತಿರಿ.

ಪವರ್‌ಶೆಲ್ ಉಳಿಸಲು ನೀಡುತ್ತದೆ - “ನೀವು ಚಲಾಯಿಸಲಿರುವ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಉಳಿಸಲಾಗುತ್ತದೆ.”, ನಾವು ಒಪ್ಪುತ್ತೇವೆ ಮತ್ತು ಪವರ್‌ಶೆಲ್‌ನಿಂದ ಫೈಲ್ ಅನ್ನು ಸಿ: ಪೋಶ್‌ಟ್ರಾನ್ಸ್‌ಲೇಟ್ ಹೆಸರಿನೊಂದಿಗೆ ಉಳಿಸುತ್ತೇವೆ myfirstbotBT100.

ಪ್ರಾರಂಭದ ನಂತರ, ಕೆಳಗಿನ ಪಠ್ಯ ವಿಂಡೋದಲ್ಲಿ ನಾವು ಡೇಟಾ ಟೇಬಲ್ ಅನ್ನು ಪಡೆಯುತ್ತೇವೆ: 

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

ನನ್ನ ಬಳಿ 5.1 ಇದೆ, ಅದು ಸಾಕು. ನೀವು ಹಳೆಯ ವಿಂಡೋಸ್ 7/8 ಅನ್ನು ಹೊಂದಿದ್ದರೆ ನಂತರ ಯಾವುದೇ ದೊಡ್ಡ ವ್ಯವಹಾರವಿಲ್ಲ - ಆದಾಗ್ಯೂ PowerShell ಅನ್ನು ಆವೃತ್ತಿ 5 ಗೆ ನವೀಕರಿಸಬೇಕಾಗುತ್ತದೆ - ಉದಾ. ಸೂಚನೆಗಳು.

ಕೆಳಗಿನ ಆಜ್ಞಾ ಸಾಲಿನಲ್ಲಿ Get-Date ಎಂದು ಟೈಪ್ ಮಾಡಿ, Enter ಒತ್ತಿ, ಸಮಯವನ್ನು ನೋಡಿ, ಆಜ್ಞೆಯೊಂದಿಗೆ ರೂಟ್ ಫೋಲ್ಡರ್‌ಗೆ ಹೋಗಿ
cd
ಮತ್ತು cls ಆಜ್ಞೆಯೊಂದಿಗೆ ಪರದೆಯನ್ನು ತೆರವುಗೊಳಿಸಿ (ಇಲ್ಲ, ನೀವು rm ಅನ್ನು ಬಳಸುವ ಅಗತ್ಯವಿಲ್ಲ)

ಈಗ ಏನು ಕೆಲಸ ಮಾಡುತ್ತದೆ ಮತ್ತು ಹೇಗೆ ಎಂದು ಪರಿಶೀಲಿಸೋಣ - ಕೋಡ್ ಅನ್ನು ಸಹ ಬರೆಯೋಣ, ಆದರೆ ಎರಡು ಸಾಲುಗಳನ್ನು ಬರೆಯೋಣ ಮತ್ತು ಅವರು ಏನು ಮಾಡುತ್ತಾರೆ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಪ್ರಯತ್ನಿಸಿ. # ಚಿಹ್ನೆಯೊಂದಿಗೆ ಗೆಟ್-ಹೋಸ್ಟ್‌ನೊಂದಿಗೆ ಲೈನ್ ಅನ್ನು ಕಾಮೆಂಟ್ ಮಾಡೋಣ ಮತ್ತು ಸ್ವಲ್ಪ ಸೇರಿಸಿ.

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

(ಆಸಕ್ತಿದಾಯಕ ಸಂಗತಿಯೆಂದರೆ ಹ್ಯಾಬ್ರೆಯಲ್ಲಿ ಕೋಡ್ ಫಾರ್ಮ್ಯಾಟಿಂಗ್ ಡ್ರಾಪ್-ಡೌನ್ ಪಟ್ಟಿಯಲ್ಲಿ ಎರಡು ಡಜನ್ ಆಯ್ಕೆಗಳಿವೆ - ಆದರೆ ಪವರ್‌ಶೆಲ್ ಇಲ್ಲ. ಡಾಸ್ ಇದೆ. ಪರ್ಲ್ ಇದೆ.)

ಮತ್ತು GUI ನಿಂದ F5 ಅಥವಾ ">" ಒತ್ತುವ ಮೂಲಕ ಕೋಡ್ ಅನ್ನು ರನ್ ಮಾಡೋಣ.

ನಾವು ಈ ಕೆಳಗಿನ ಔಟ್ಪುಟ್ ಅನ್ನು ಪಡೆಯುತ್ತೇವೆ:

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

ಈಗ ಈ ಎರಡು ಸಾಲುಗಳನ್ನು ಮತ್ತು ಕೆಲವು ಆಸಕ್ತಿದಾಯಕ ಅಂಶಗಳನ್ನು ನೋಡೋಣ ಇದರಿಂದ ನಾವು ಭವಿಷ್ಯದಲ್ಲಿ ಇದಕ್ಕೆ ಹಿಂತಿರುಗುವುದಿಲ್ಲ.

ಪ್ಯಾಸ್ಕಲ್‌ಗಿಂತ ಭಿನ್ನವಾಗಿ (ಮತ್ತು ಮಾತ್ರವಲ್ಲ), ಪವರ್‌ಶೆಲ್ ಸ್ವತಃ ವೇರಿಯಬಲ್‌ಗೆ ಯಾವ ಪ್ರಕಾರವನ್ನು ನಿಯೋಜಿಸಬೇಕೆಂದು ನಿರ್ಧರಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತದೆ; ಇದರ ಬಗ್ಗೆ ಹೆಚ್ಚಿನ ವಿವರಗಳನ್ನು ಲೇಖನದಲ್ಲಿ ಬರೆಯಲಾಗಿದೆ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳಲ್ಲಿ ಟೈಪಿಂಗ್ ಕುರಿತು ಶೈಕ್ಷಣಿಕ ಕಾರ್ಯಕ್ರಮ
ಆದ್ದರಿಂದ, $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")...

ನೀವು ನೋಡುವಂತೆ, ಟೈಪ್ ನೇಮ್ ಪ್ರಕಾರದ ವೇರಿಯೇಬಲ್: 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 | ಪ್ರಕಾರ ಸದಸ್ಯತ್ವವನ್ನು ಪಡೆಯುವುದು 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) ಫೈಲ್ A ಅನ್ನು ಪಡೆಯುತ್ತೀರಿ ನಿಲ್ಲಿಸಿ ನಿರೀಕ್ಷಿಸಿ.
# 

$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 ಗೆಟ್-ರ್ಯಾಂಡಮ್ ನಡುವೆ ಯಾದೃಚ್ಛಿಕ ಪೂರ್ಣಾಂಕವನ್ನು ಪಡೆಯಿರಿ - ಗರಿಷ್ಠ 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

ಬೋಟ್ / ಸಂದೇಶ 10, / ಸಂದೇಶ 11, / ಸಂದೇಶ 12, / ಪದ ಮತ್ತು ಮತ್ತೆ / ಪದ ಮತ್ತು / ಹಲೋ ಅನ್ನು ಕಳುಹಿಸೋಣ.
ನಮಗೆ ಸಿಕ್ಕಿದ್ದನ್ನು ನೋಡೋಣ: 

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

ಸ್ವೀಕರಿಸಿದ ಎಲ್ಲದರ ಮೂಲಕ ಹೋಗೋಣ ಮತ್ತು ಸಂದೇಶವು / ಪದವಾಗಿದ್ದರೆ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಕಳುಹಿಸೋಣ
ನಿರ್ಮಾಣದ ಸಂದರ್ಭದಲ್ಲಿ, ಕೆಲವರು if-elseif ಎಂದು ವಿವರಿಸುತ್ತಾರೆ, ಇದನ್ನು ಪವರ್‌ಶೆಲ್‌ನಲ್ಲಿ ಕರೆಯಲಾಗುತ್ತದೆ ಸ್ವಿಚ್ ಮೂಲಕ. ಅದೇ ಸಮಯದಲ್ಲಿ, ಕೆಳಗಿನ ಕೋಡ್ -ವೈಲ್ಡ್ಕಾರ್ಡ್ ಕೀಲಿಯನ್ನು ಬಳಸುತ್ತದೆ, ಇದು ಸಂಪೂರ್ಣವಾಗಿ ಅನಗತ್ಯ ಮತ್ತು ಹಾನಿಕಾರಕವಾಗಿದೆ.

ಕೆಲವು ಕೋಡ್ #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 ಪ್ಯಾರಾಮೀಟರ್ ಅಗತ್ಯವಿದೆ, ಮತ್ತು &ಟೈಮ್ಔಟ್, &ಮಿತಿ, &parse_mode=HTML ಮತ್ತು &disable_web_page_preview=true ಇನ್ನೂ ಅಗತ್ಯವಿಲ್ಲ.

ಗಾಗಿ ದಾಖಲೆ ಟೆಲಿಗ್ರಾಮ್ ಎಪಿಐ ಇಲ್ಲಿದೆ
ಇದು ಬಿಳಿ ಮತ್ತು ಇಂಗ್ಲಿಷ್‌ನಲ್ಲಿ ಹೇಳುತ್ತದೆ:
ಹಿಂತಿರುಗಿಸಬೇಕಾದ ಮೊದಲ ನವೀಕರಣದ ಗುರುತಿಸುವಿಕೆ. ಹಿಂದೆ ಸ್ವೀಕರಿಸಿದ ಅಪ್‌ಡೇಟ್‌ಗಳ ಐಡೆಂಟಿಫೈಯರ್‌ಗಳಲ್ಲಿ ಅತ್ಯಧಿಕಕ್ಕಿಂತ ಒಂದಕ್ಕಿಂತ ಹೆಚ್ಚಿನದಾಗಿರಬೇಕು. ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ, ನವೀಕರಣಗಳು ಮೊದಲಿನಿಂದ ಪ್ರಾರಂಭವಾಗುತ್ತವೆ
ದೃ on ೀಕರಿಸಲಾಗಿಲ್ಲ ನವೀಕರಣವನ್ನು ಹಿಂತಿರುಗಿಸಲಾಗುತ್ತದೆ. ಗೆಟ್‌ಅಪ್‌ಡೇಟ್ಸ್‌ನೊಂದಿಗೆ ಕರೆ ಮಾಡಿದ ತಕ್ಷಣ ನವೀಕರಣವನ್ನು ದೃಢೀಕರಿಸಲಾಗಿದೆ ಎಂದು ಪರಿಗಣಿಸಲಾಗುತ್ತದೆ ಆಫ್ಸೆಟ್ ಹೆಚ್ಚಿನ ಅದರ update_id ಗಿಂತ. ನವೀಕರಣಗಳ ಸರದಿಯ ಅಂತ್ಯದಿಂದ -ಆಫ್‌ಸೆಟ್ ನವೀಕರಣದಿಂದ ಪ್ರಾರಂಭವಾಗುವ ನವೀಕರಣಗಳನ್ನು ಹಿಂಪಡೆಯಲು ನಕಾರಾತ್ಮಕ ಆಫ್‌ಸೆಟ್ ಅನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಬಹುದು. ಹಿಂದಿನ ಎಲ್ಲಾ ನವೀಕರಣಗಳನ್ನು ಮರೆತುಬಿಡಲಾಗುತ್ತದೆ.

ನೋಡೋಣ:

$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

ಕಾಮೆಂಟ್ ಅನ್ನು ಸೇರಿಸಿ