ಮೌಲ್ಯಗಳ ಪಟ್ಟಿ ಅಂಶ 1c. ಸಾರ್ವತ್ರಿಕ ಸಂಗ್ರಹ ರಚನೆ

ಪೂರ್ಣ ಸಿಂಟ್ಯಾಕ್ಸ್(ವಿಸ್ತರಿಸಲು ಕ್ಲಿಕ್ ಮಾಡಿ)

ಪಟ್ಟಿ ಮೌಲ್ಯಗಳು

ವಿವರಣೆ:

ಮೌಲ್ಯಗಳ ಪಟ್ಟಿಯು ಡೇಟಾಬೇಸ್‌ನಲ್ಲಿ ಉಳಿಸದ ವಸ್ತುವಾಗಿದೆ, ಇದು ಇಂಟರ್ಫೇಸ್ ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಹರಿಸಲು ಮತ್ತು ಅವುಗಳನ್ನು ಕುಶಲತೆಯಿಂದ (ಅಂಶಗಳನ್ನು ಸೇರಿಸಿ, ಸಂಪಾದಿಸಿ, ಅಳಿಸಿ, ವಿಂಗಡಿಸಿ) ಡೈನಾಮಿಕ್ ಮೌಲ್ಯಗಳ ಸೆಟ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಇದನ್ನು ಯಾವುದೇ ರೀತಿಯ ಮೌಲ್ಯಗಳೊಂದಿಗೆ ತುಂಬಿಸಬಹುದು, ಅಂದರೆ. ಒಂದು ಪಟ್ಟಿಯಲ್ಲಿ, ಸಂಗ್ರಹಿಸಿದ ಮೌಲ್ಯಗಳ ಪ್ರಕಾರಗಳು ವಿಭಿನ್ನವಾಗಿರಬಹುದು. ಸಂಕೀರ್ಣ ಅಲ್ಗಾರಿದಮ್ ಬಳಸಿ ರಚಿಸಲಾದ ಸಂಭವನೀಯ ದಾಖಲೆಗಳ ಪಟ್ಟಿಯಿಂದ ನಿರ್ದಿಷ್ಟ ಡಾಕ್ಯುಮೆಂಟ್‌ನ ಆಯ್ಕೆಯನ್ನು ಆಯೋಜಿಸುವುದು ಈ ವಸ್ತುವನ್ನು ಬಳಸುವ ಒಂದು ಉದಾಹರಣೆಯಾಗಿದೆ.

ಸಂಗ್ರಹದ ವಸ್ತುಗಳು: ವ್ಯಾಲ್ಯೂಲಿಸ್ಟ್ ಎಲಿಮೆಂಟ್

ಆಪರೇಟರ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಸಂಗ್ರಹಣೆಯನ್ನು ಬೈಪಾಸ್ ಮಾಡಲು ವಸ್ತುವಿಗೆ ಸಾಧ್ಯವಿದೆ ಪ್ರತಿಯೊಂದಕ್ಕೂ... ಇಂದ... ಸೈಕಲ್. ಟ್ರಾವರ್ಸಲ್ ಸಂಗ್ರಹದ ಅಂಶಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡುತ್ತದೆ.

[...] ಆಪರೇಟರ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಸಂಗ್ರಹಣಾ ಅಂಶವನ್ನು ಪ್ರವೇಶಿಸಲು ಸಾಧ್ಯವಿದೆ. ಅಂಶದ ಸೂಚಿಯನ್ನು ಆರ್ಗ್ಯುಮೆಂಟ್ ಆಗಿ ರವಾನಿಸಲಾಗಿದೆ ( 0 ರಿಂದ ಸಂಖ್ಯೆ).

ಗುಣಲಕ್ಷಣಗಳು:

ವಿಧಾನಗಳು:

ವಿನ್ಯಾಸಕರು:

ಈ ಲೇಖನ ಯಾವುದರ ಬಗ್ಗೆ?

ಈ ಲೇಖನವು "1C ಅಭಿವೃದ್ಧಿಯಲ್ಲಿ ಮೊದಲ ಹಂತಗಳು" ಲೇಖನಗಳ ಸರಣಿಯನ್ನು ಮುಂದುವರಿಸುತ್ತದೆ. ಇದು ಸಾರ್ವತ್ರಿಕ ಸಂಗ್ರಹಣೆಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವ ತತ್ವಗಳನ್ನು ಒಳಗೊಂಡಿದೆ. ಲೇಖನವನ್ನು ಓದಿದ ನಂತರ, ನೀವು ಕಲಿಯುವಿರಿ:

• ಸಾರ್ವತ್ರಿಕ ಸಂಗ್ರಹಣೆಗಳು ಯಾವುವು, ಮತ್ತು ಯಾವಾಗ ಮತ್ತು ಯಾವ ಸಂದರ್ಭಗಳಲ್ಲಿ ಅವುಗಳನ್ನು ಬಳಸಬೇಕು?
• ಎಲ್ಲಾ ಸಾರ್ವತ್ರಿಕ ಸಂಗ್ರಹಣೆಗಳು ಸಾಮಾನ್ಯವಾಗಿ ಏನು ಹೊಂದಿವೆ? ಅವರೆಲ್ಲರೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ನೀವು ಯಾವ ತಂತ್ರಗಳನ್ನು ಬಳಸಬಹುದು?
• ಅರೇ ಎಂದರೇನು, ಅದನ್ನು ಹೇಗೆ ಮತ್ತು ಯಾವಾಗ ಬಳಸಬೇಕು? ಅವನು ಯಾವ ವಿಧಾನಗಳನ್ನು ಹೊಂದಿದ್ದಾನೆ?
• ರಚನೆಯನ್ನು ಏಕೆ ಬಳಸಬೇಕು? ಇದು ಶ್ರೇಣಿಯಿಂದ ಹೇಗೆ ಭಿನ್ನವಾಗಿದೆ?
• ನೀವು ಮೌಲ್ಯಗಳ ಪಟ್ಟಿಯನ್ನು ಯಾವಾಗ ಬಳಸಬೇಕು? ಅದನ್ನು ಫಾರ್ಮ್‌ನಲ್ಲಿ ಪ್ರದರ್ಶಿಸುವುದು ಹೇಗೆ?
• ಅನುಸರಣೆ - ಅದು ಏನು ಮತ್ತು ಅದನ್ನು ಯಾವಾಗ ಬಳಸಬೇಕು? ರಚನೆಯ ಅನುಕೂಲಗಳು ಯಾವುವು?
• ಮೌಲ್ಯದ ಕೋಷ್ಟಕವನ್ನು ಯಾವುದಕ್ಕಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ? ಅದರ ರಚನೆಯನ್ನು ಹೇಗೆ ವಿವರಿಸುವುದು? ಸಾಲುಗಳನ್ನು ಸೇರಿಸುವುದು/ತೆಗೆಯುವುದು ಹೇಗೆ? ಅದನ್ನು ಫಾರ್ಮ್‌ನಲ್ಲಿ ಪ್ರದರ್ಶಿಸುವುದು ಹೇಗೆ?
• ಮೌಲ್ಯಗಳ ಮರ - ಇದನ್ನು ಯಾವುದಕ್ಕಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ? ಫಾರ್ಮ್ ಅನ್ನು ಭರ್ತಿ ಮಾಡುವುದು ಮತ್ತು ಪ್ರದರ್ಶಿಸುವುದು ಹೇಗೆ? ಅದರೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವುದು ಹೇಗೆ?

ಅನ್ವಯಿಸುವಿಕೆ

ಲೇಖನವು ಪ್ರಸ್ತುತ ಆವೃತ್ತಿಯ 1C: ಎಂಟರ್‌ಪ್ರೈಸ್ 8.3 ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ ಅನ್ನು ಚರ್ಚಿಸುತ್ತದೆ.

1C ಯಲ್ಲಿ ಸಾರ್ವತ್ರಿಕ ಸಂಗ್ರಹಣೆಗಳೊಂದಿಗೆ ಹೇಗೆ ಕೆಲಸ ಮಾಡುವುದು

ಮೌಲ್ಯಗಳ ಸಂಗ್ರಹವು ಸಾಮಾನ್ಯವಾಗಿ ಯಾವುದೇ ಸಂಖ್ಯೆಯ ಅಂಶಗಳನ್ನು ಒಳಗೊಂಡಿರುವ ಧಾರಕವಾಗಿದೆ. ಆದಾಗ್ಯೂ, ಸಾಮಾನ್ಯವಾಗಿ ಡೇಟಾ ಪ್ರಕಾರಕ್ಕೆ ಯಾವುದೇ ಕಟ್ಟುನಿಟ್ಟಾದ ನಿರ್ಬಂಧಗಳಿಲ್ಲ.

ನೀವು ಸಾಮಾನ್ಯ ಸಂಗ್ರಹಕ್ಕೆ ಮೌಲ್ಯಗಳನ್ನು ಸೇರಿಸಬಹುದು. ಸಂಗ್ರಹಣೆಯಲ್ಲಿನ ಎಲ್ಲಾ ಮೌಲ್ಯಗಳನ್ನು ದಾಟಬಹುದು. ಈ ಸಂಗ್ರಹಗಳನ್ನು ಮುಖ್ಯವಾಗಿ ಅಲ್ಗಾರಿದಮ್‌ಗಳಲ್ಲಿ ಕೆಲವು ರೀತಿಯ ಸಂಸ್ಕರಣೆಗಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ. ಆ. ಇವು ಕೆಲವು ಕ್ರಿಯಾತ್ಮಕ ರಚನೆಗಳು, ಇದು ಅಲ್ಗಾರಿದಮ್ ಅವಧಿಯವರೆಗೆ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ.

ಸಂಗ್ರಹಣೆಗಳನ್ನು ಡೇಟಾಬೇಸ್‌ನಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾಗಿಲ್ಲ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಬಹಳ ಮುಖ್ಯ (ನಾವು ಮೌಲ್ಯದ ಅಂಗಡಿ ಡೇಟಾ ಪ್ರಕಾರದ ಬಗ್ಗೆ ಮಾತನಾಡುವುದಿಲ್ಲ, ಅದು ಯಾವುದೇ ರೀತಿಯ ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸಬಹುದು).

ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ ವಿವಿಧ ರೀತಿಯಸಾರ್ವತ್ರಿಕ ಸಂಗ್ರಹಣೆಗಳು: ರಚನೆ, ರಚನೆ, ಹೊಂದಾಣಿಕೆ, ಸ್ಥಿರ ಅರೇ, ಮೌಲ್ಯ ಕೋಷ್ಟಕ, ಕೋಷ್ಟಕ ಭಾಗಇತ್ಯಾದಿ ಆದರೆ ಎಲ್ಲಾ ಸಂಗ್ರಹಣೆಗಳು ಒಂದೇ ರೀತಿಯ ನಡವಳಿಕೆಯನ್ನು ಹೊಂದಿವೆ.

ಕಾರ್ಯದ ಕಾರ್ಯಾಚರಣೆಯ ಪರಿಣಾಮವಾಗಿ ಸಂಗ್ರಹವನ್ನು ರಚಿಸಬಹುದು (ಕಾರ್ಯವು ಸಾರ್ವತ್ರಿಕ ಸಂಗ್ರಹವನ್ನು ಮೌಲ್ಯವಾಗಿ ಹಿಂದಿರುಗಿಸುತ್ತದೆ).

ಲಭ್ಯವಿದೆ ಹೊಸ ಸಂಗ್ರಹಹಸ್ತಚಾಲಿತವಾಗಿ ಕನ್ಸ್ಟ್ರಕ್ಟರ್ ಅನ್ನು ಪ್ರವೇಶಿಸುವ ಮೂಲಕ ಮತ್ತು ವರ್ಗದ ಉದಾಹರಣೆಯನ್ನು ರಚಿಸುವ ಮೂಲಕ.

ಉದಾಹರಣೆಗೆ: OurArray = New Array;

ಅನೇಕ ಜೆನೆರಿಕ್ ಸಂಗ್ರಹಗಳಿಗೆ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್‌ಗಳನ್ನು ಪ್ಯಾರಾಮೀಟರ್ ಮಾಡಲಾಗಿದೆ.

ಆದ್ದರಿಂದ, ಕನ್ಸ್ಟ್ರಕ್ಟರ್‌ನಲ್ಲಿ ಅನುಗುಣವಾದ ಆಯಾಮಗಳಲ್ಲಿ ನೀವು ಸದಸ್ಯರ ಸಂಖ್ಯೆಯನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಬಹುದು. ಆ. ನೀವು ತಕ್ಷಣ ಬಹುಆಯಾಮದ ಘೋಷಿಸಬಹುದು .

ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್‌ನ ಅನುಗುಣವಾದ ವಿವರಣೆಯು ಸಿಂಟ್ಯಾಕ್ಸ್ ಸಹಾಯಕದಲ್ಲಿದೆ.

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

ಆದರೆ ನಿಯತಾಂಕಗಳು ಐಚ್ಛಿಕವಾಗಿವೆ;

ಕನ್ಸ್ಟ್ರಕ್ಟರ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಯಾವುದೇ ಸಾರ್ವತ್ರಿಕ ಸಂಗ್ರಹವನ್ನು ರಚಿಸಬಹುದು (ವಿನಾಯಿತಿ ಟೇಬಲ್ ಭಾಗಗಳು, ಇದು ಕಾನ್ಫಿಗರೇಶನ್ ವಸ್ತುಗಳಂತೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ).

ಸಾರ್ವತ್ರಿಕ ಸಂಗ್ರಹಣೆಗಳಿಗೆ ಅಂತಹವುಗಳಿವೆ ಸಾಮಾನ್ಯ ಪರಿಕಲ್ಪನೆಗಳು, ಸೂಚ್ಯಂಕ ಮತ್ತು ಸಂಖ್ಯೆಯಂತೆ. ಸಂಗ್ರಹದ ಪ್ರತಿಯೊಂದು ಅಂಶವು ಸೂಚ್ಯಂಕವನ್ನು ಹೊಂದಿದೆ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಸೂಚ್ಯಂಕವು ಶೂನ್ಯದಿಂದ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ.

ಒಂದು ಅಂಶವನ್ನು ಪ್ರವೇಶಿಸಲು ನಮ್ಮ ಅರೇ, ಇದಕ್ಕಾಗಿ ನೀವು ಸೂಚ್ಯಂಕ ಪ್ರವೇಶವನ್ನು ಬಳಸಬಹುದು, ಸೂಚ್ಯಂಕವನ್ನು ಚದರ ಬ್ರಾಕೆಟ್ಗಳಲ್ಲಿ ಸೂಚಿಸಲಾಗುತ್ತದೆ.

ಉದಾಹರಣೆಗೆ, ನಮ್ಮ ಅರೇ. ಈ ಸಂದರ್ಭದಲ್ಲಿ ಸಿಸ್ಟಮ್ ಅರೇ ಅಂಶವನ್ನು ಸೂಚ್ಯಂಕ 3 ನೊಂದಿಗೆ ಹಿಂತಿರುಗಿಸುತ್ತದೆ ಮತ್ತು ಕ್ರಮವಾಗಿ ಇದು ರಚನೆಯ ನಾಲ್ಕನೇ ಅಂಶವಾಗಿದೆ ಎಂಬುದನ್ನು ದಯವಿಟ್ಟು ಗಮನಿಸಿ.

ಕೆಲವು ಸಂಗ್ರಹಗಳಿಗೆ ಒಂದು ಸಾಲಿನ ಸಂಖ್ಯೆಯ ಪರಿಕಲ್ಪನೆಯೂ ಇದೆ. ಸಾಲಿನ ಸಂಖ್ಯೆ ಒಂದರಿಂದ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ಕೋಷ್ಟಕ ಭಾಗಕ್ಕೆ ಸಾಲು ಸಂಖ್ಯೆಯಂತಹ ಆಸ್ತಿ ಇದೆ. ನಾವು ಸಾಲಿನ ಸಂಖ್ಯೆಯನ್ನು ತಿಳಿದಿದ್ದರೆ ಮತ್ತು ಅದನ್ನು ಸೂಚ್ಯಂಕದಿಂದ ಪ್ರವೇಶಿಸಲು ಬಯಸಿದರೆ, ನಾವು ರೇಖೆಯ ಸಂಖ್ಯೆಗಿಂತ ಕಡಿಮೆ ಮೌಲ್ಯವನ್ನು ಸೂಚ್ಯಂಕವಾಗಿ ಬಳಸಬೇಕು ಎಂಬುದನ್ನು ನೆನಪಿನಲ್ಲಿಡುವುದು ಮುಖ್ಯ.

ಲೈನ್ ಸಂಖ್ಯೆಯ ಪರಿಕಲ್ಪನೆಯು ಎಲ್ಲಾ ಸಂಗ್ರಹಣೆಗಳಲ್ಲಿ ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲ, ಆದರೆ ಮುಖ್ಯವಾಗಿ ಬಳಕೆದಾರ ಇಂಟರ್ಫೇಸ್ನಲ್ಲಿ ಪ್ರದರ್ಶಿಸಬಹುದಾದವುಗಳಲ್ಲಿ.

ಎಲ್ಲಾ ಸಂಗ್ರಹಣೆಗಳು ಸಂಗ್ರಹ ಅಂಶ ಟ್ರಾವರ್ಸಲ್ ಅನ್ನು ಬಳಸುತ್ತವೆ. ಬೈಪಾಸ್ ಎರಡು ರೀತಿಯಲ್ಲಿ ಸಾಧ್ಯ: ಸೈಕಲ್ ಫಾರ್ಮತ್ತು ಪ್ರತಿಯೊಂದಕ್ಕೂ ಸೈಕಲ್.

ಹೆಚ್ಚಿನ ಸಾಮಾನ್ಯ ಸಂಗ್ರಹಣೆಗಳಿಗೆ, ಅನ್ವಯಿಸುವ ವಿಧಾನಗಳೆಂದರೆ ಎಣಿಕೆ, ಸೂಚ್ಯಂಕ, ಸೇರಿಸಿ, ಸೇರಿಸು, ಅಳಿಸಿ ಮತ್ತು ಹುಡುಕಿ.

ಎಣಿಕೆ ಎನ್ನುವುದು ಸಂಗ್ರಹದಲ್ಲಿರುವ ಅಂಶಗಳ ಸಂಖ್ಯೆಯನ್ನು ಹಿಂದಿರುಗಿಸುವ ಒಂದು ಕಾರ್ಯವಾಗಿದೆ. ಇದನ್ನು ಚಕ್ರದ ಮೊದಲು ಬಳಸಬಹುದು ಫಾರ್, ಚಿತ್ರದಲ್ಲಿ ತೋರಿಸಿರುವಂತೆ.

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

ಮೌಲ್ಯಗಳ ಕೋಷ್ಟಕ- ಇದು ಸಾಲುಗಳ ನಿರ್ದಿಷ್ಟ ಸಂಗ್ರಹವಾಗಿದೆ, ಸಾಲುಗಳು ವಿಭಿನ್ನ ಕಾಲಮ್‌ಗಳನ್ನು ಒಳಗೊಂಡಿರಬಹುದು ವಿವಿಧ ರೀತಿಯಮೌಲ್ಯಗಳನ್ನು.

ಪ್ರತಿಯೊಂದು ಸಾಲು ಸ್ವತಂತ್ರ ಘಟಕವನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ. ಈ ಸಾಲಿನ ಮೂಲಕ ನೀವು ಅದಕ್ಕೆ ಲಿಂಕ್ ಪಡೆಯಬಹುದು; ಈ ಸಾಲಿನಲ್ಲಿರುವ ಕಾಲಮ್‌ಗಳ ಮೌಲ್ಯಗಳನ್ನು ನೀವು ಪ್ರವೇಶಿಸಬಹುದು.

ನಿರ್ದಿಷ್ಟ ಸಾಲಿಗೆ ಯಾವ ಸೂಚ್ಯಂಕ ಅನುರೂಪವಾಗಿದೆ ಎಂಬುದನ್ನು ನಿರ್ಧರಿಸಲು ಸೂಚ್ಯಂಕ ವಿಧಾನವು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ (ಅಂದರೆ, ಕೋಷ್ಟಕದಲ್ಲಿನ ಸಾಲಿನ ಪ್ರಸ್ತುತ ಸ್ಥಾನ). ಸೂಚ್ಯಂಕ ಮೌಲ್ಯಗಳು ಶೂನ್ಯದಿಂದ ಪ್ರಾರಂಭವಾಗುತ್ತವೆ.

ಹೊಸ ಮೌಲ್ಯಗಳನ್ನು ಸೇರಿಸುವ ವಿಧಾನಗಳು ಈ ಸಂಗ್ರಹಯಾವುದೇ ಸಾರ್ವತ್ರಿಕ ಸಂಗ್ರಹಣೆಯಲ್ಲಿ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ. 0 ರಿಂದ 10 ರವರೆಗಿನ ಮೌಲ್ಯಗಳೊಂದಿಗೆ ಅರೇ ಅನ್ನು ಎರಡು ರೀತಿಯಲ್ಲಿ ತುಂಬುವುದು ಹೇಗೆ ಎಂಬುದನ್ನು ಚಿತ್ರ ತೋರಿಸುತ್ತದೆ.

ಅರೇಗೆ ಒಂದು ಅಂಶವನ್ನು ಸೇರಿಸಲು ನಾವು ವಿಧಾನವನ್ನು ಬಳಸಬಹುದು ಸೇರಿಸಿ, ಬ್ರಾಕೆಟ್‌ಗಳಲ್ಲಿ ಸೇರಿಸಬೇಕಾದ ಮೌಲ್ಯವನ್ನು ಸೂಚಿಸಿ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಮೌಲ್ಯವನ್ನು ಪಟ್ಟಿಯ ಅಂತ್ಯಕ್ಕೆ ಸೇರಿಸಲಾಗುತ್ತದೆ, ಅಂದರೆ. ಕೊನೆಯ ಸ್ಥಾನದಿಂದಾಗಿ ರಚನೆಯು ನಿರಂತರವಾಗಿ ಹೆಚ್ಚಾಗುತ್ತದೆ.

ಸಂಗ್ರಹಕ್ಕೆ ಮೌಲ್ಯಗಳನ್ನು ಸೇರಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುವ ಮತ್ತೊಂದು ವಿಧಾನವೆಂದರೆ ಸೇರಿಸು. ಇದು ವಿಧಾನಕ್ಕಿಂತ ಭಿನ್ನವಾಗಿದೆ ಸೇರಿಸಿಸೇರಿಸಿದ ಅಂಶವನ್ನು ಎಲ್ಲಿ ಸೇರಿಸಬೇಕೆಂದು ನೀವು ನಿರ್ದಿಷ್ಟಪಡಿಸಬಹುದು.

ವಾಕ್ಯ ರಚನೆ: ಸೇರಿಸಿ (,)

ಮೊದಲ ಪ್ಯಾರಾಮೀಟರ್ ಹೊಸ ಮೌಲ್ಯವನ್ನು ಸೇರಿಸುವ ಸೂಚಿಯನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತದೆ. ಆ. ಉದಾಹರಣೆಗೆ, ಪ್ರತಿ ಮೌಲ್ಯವನ್ನು ಪಟ್ಟಿಯ ಪ್ರಾರಂಭದಲ್ಲಿ ಸೇರಿಸಬೇಕು ಎಂದು ನಾವು ನಿರ್ದಿಷ್ಟಪಡಿಸಬಹುದು (ಮೇಲಿನ ಚಿತ್ರದಲ್ಲಿ ಎರಡನೇ ವಿಧಾನ).

ಸಂಗ್ರಹದಿಂದ ಅಂಶಗಳನ್ನು ತೆಗೆದುಹಾಕಲು, ವಿಧಾನವನ್ನು ಬಳಸಿ ಅಳಿಸಿ. ಅಳಿಸುವ ವಿಧಾನವು ನಾವು ಯಾವ ಅಂಶವನ್ನು ಅಳಿಸುತ್ತೇವೆ ಎಂಬುದನ್ನು ಸೂಚ್ಯಂಕದ ಮೂಲಕ ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತದೆ.

ವಾಕ್ಯ ರಚನೆ: ಅಳಿಸು()
ಬಳಕೆಯ ಉದಾಹರಣೆ: OurArray.Delete(5);

ತಂತಿಗಳು ಸ್ವತಂತ್ರ ಘಟಕವನ್ನು ಪ್ರತಿನಿಧಿಸುವ ಸಂಗ್ರಹಣೆಗಳಿಗೆ (ಉದಾಹರಣೆಗೆ, ಫಾರ್ ಮೌಲ್ಯ ಕೋಷ್ಟಕಗಳು), ನಂತರ ಈ ಸಾಲನ್ನು ಅಳಿಸಲು ನಾವು ಸೂಚ್ಯಂಕವನ್ನು ಪಡೆಯುವ ವಿಧಾನವನ್ನು ಸಹ ಬಳಸಬಹುದು.

ಬಹುತೇಕ ಎಲ್ಲಾ ಸಂಗ್ರಹಣೆಗಳು ಮೌಲ್ಯವನ್ನು ಹುಡುಕುವ ವಿಧಾನವನ್ನು ಹೊಂದಿವೆ - ಹುಡುಕಿ. ನಾವು ಕಂಡುಹಿಡಿಯಲು ಬಯಸುವ ಮೌಲ್ಯವನ್ನು ವಿಧಾನಕ್ಕೆ ರವಾನಿಸಲಾಗಿದೆ. ಕೆಲವು ಸಂಗ್ರಹಣೆಗಳು ಕೆಲವು ನಿರ್ಬಂಧಗಳನ್ನು ಹೊಂದಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.

ಉದಾಹರಣೆಗೆ, ಇನ್ ಮೌಲ್ಯಗಳ ಕೋಷ್ಟಕನೀವು ಹುಡುಕಲು ಬಯಸುವ ಸಾಲುಗಳು ಮತ್ತು ಕಾಲಮ್‌ಗಳನ್ನು ನೀವು ನಿರ್ದಿಷ್ಟಪಡಿಸಬಹುದು.

ಮೌಲ್ಯವು ಕಂಡುಬಂದರೆ, ಈ ವಿಧಾನವು ಸೂಚ್ಯಂಕ ಅಥವಾ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಮೌಲ್ಯವು ಕಂಡುಬರದಿದ್ದರೆ, ಪ್ರಕಾರದ ಮೌಲ್ಯವನ್ನು ಹಿಂತಿರುಗಿಸಲಾಗುತ್ತದೆ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿಲ್ಲ. ಅರೇಗೆ ಸಂಬಂಧಿಸಿದಂತೆ, ಹಿಂತಿರುಗಿಸುತ್ತದೆ ಸೂಚ್ಯಂಕ, ಅಥವಾ ಮೌಲ್ಯ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿಲ್ಲ.

ಬಳಕೆಯ ಉದಾಹರಣೆ: OurVariable = OurArray.Find(8);

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

ಅರೇಗಾಗಿ ಹೆಚ್ಚುವರಿ ವಿಧಾನಗಳು

ವಿಧಾನ BBorder()ಒಂದು ಮೈನಸ್ ಅಂಶಗಳ ಸಂಖ್ಯೆಯನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಆ. ನಾವು ಲೂಪ್ ಅನ್ನು ಬಳಸಿದರೆ ಫಾರ್, ನಂತರ ಪ್ರಮಾಣ ವಿಧಾನದ ಬದಲಿಗೆ ನಾವು ತಕ್ಷಣವೇ ವಿಧಾನವನ್ನು ಬಳಸಬಹುದು ಗಡಿ().

ನಿರ್ದಿಷ್ಟವಾಗಿ, ವೇರಿಯೇಬಲ್ QuantityInArray ಅನ್ನು ವಿಭಿನ್ನವಾಗಿ ವ್ಯಾಖ್ಯಾನಿಸಬಹುದು:

QuantityInArray = OurArray.InBorder();
ನಂತರ, ಚಕ್ರವನ್ನು ಸ್ವತಃ ವಿವರಿಸುವಾಗ, ಈ ವೇರಿಯಬಲ್ನಿಂದ ಕಳೆಯಬಾರದು.

ಸೂಚ್ಯಂಕದಿಂದ ಅರೇ ಅಂಶಕ್ಕೆ ಮೌಲ್ಯವನ್ನು ನಿಯೋಜಿಸಲು ಸೆಟ್ ವಿಧಾನವು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.

ವಾಕ್ಯ ರಚನೆ: ಸ್ಥಾಪಿಸು(,)

ಉದಾಹರಣೆ: OurArray.Set(2,8);

ಪರ್ಯಾಯ ಆಯ್ಕೆ: OurArray = 8;

ಅರೇಗಾಗಿ ನೀವು ವಿಧಾನವನ್ನು ಬಳಸಬಹುದು ಪಡೆಯಿರಿ, ಚದರ ಆವರಣಗಳನ್ನು ಬಳಸದೆಯೇ ಸೂಚ್ಯಂಕದಲ್ಲಿ ಮೌಲ್ಯವನ್ನು ಓದುವುದಕ್ಕಾಗಿ.

ವಾಕ್ಯ ರಚನೆ: ಪಡೆಯಿರಿ()

ಉದಾಹರಣೆ: OurVariable = OurArray.Get(2);

ಪರ್ಯಾಯ ಆಯ್ಕೆ: OurVariable = OurArray;

ಸಾರ್ವತ್ರಿಕ ಸಂಗ್ರಹ ರಚನೆ

ರಚನೆಯು ಅರೇಯಂತೆ, ಅನಿಯಮಿತ ಸಂಖ್ಯೆಯ ಅಂಶಗಳನ್ನು ಹೊಂದಬಹುದು, ಆದರೆ ಅಂಶದ ವಿಷಯವು ರಚನೆಯಿಂದ ಭಿನ್ನವಾಗಿರುತ್ತದೆ.

ರಚನೆಯು ಒಂದು ಸಂಗ್ರಹವಾಗಿದೆ, ಅದರ ಪ್ರತಿಯೊಂದು ಮೌಲ್ಯವು ಜೋಡಿಯನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ. ಜೋಡಿಯ ಮೊದಲ ಅಂಶವನ್ನು ಕರೆಯಲಾಗುತ್ತದೆ ಕೀ. ಜೋಡಿಯ ಎರಡನೇ ಅಂಶವಾಗಿದೆ ಅರ್ಥ.

ಕೀಮೌಲ್ಯವನ್ನು ವಿವರಿಸುವ ಕಟ್ಟುನಿಟ್ಟಾದ ಸ್ಟ್ರಿಂಗ್ ಡೇಟಾ ಪ್ರಕಾರವಾಗಿದೆ. ಉದಾಹರಣೆಗೆ, ಕೀಲಿಗೆ"ಕೋಡ್" ಮೌಲ್ಯ 113 ಗೆ ಹೊಂದಿಕೆಯಾಗಬಹುದು; ಕೀಲಿಗೆ"ಹೆಸರು" ಎಂದರೆ "ವಾಸ್ಯ". ಮೌಲ್ಯವು ಡೇಟಾ ಪ್ರಕಾರದ ನಿರ್ಬಂಧಕ್ಕೆ ಒಳಪಟ್ಟಿಲ್ಲ.

ನಾವು ನಿಯತಾಂಕಗಳ ನಿರ್ದಿಷ್ಟ ಪಟ್ಟಿಯನ್ನು ರಚಿಸಲು ಬಯಸಿದರೆ ರಚನೆಯು ಬಳಸಲು ತುಂಬಾ ಅನುಕೂಲಕರವಾಗಿದೆ. ಈ ವೇಳೆ ರಚನೆಎಂದು ಕರೆದರು ನಮ್ಮ ರಚನೆ, ನಂತರ ನಾವು ಅದರ ಎರಡು ಮೌಲ್ಯಗಳನ್ನು ಈ ಕೆಳಗಿನಂತೆ ಉಲ್ಲೇಖಿಸುತ್ತೇವೆ: OurStructure.Code ಮತ್ತು OurStructure.Name.

ಈ ರೀತಿಯ ಪ್ರವೇಶವು ನಾವು ಒಂದು ಶ್ರೇಣಿಯಲ್ಲಿನ ಎಲ್ಲಾ ನಿಯತಾಂಕಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಿದರೆ ಮತ್ತು ಅವುಗಳನ್ನು ಸೂಚ್ಯಂಕದಿಂದ ಪ್ರವೇಶಿಸುವುದಕ್ಕಿಂತ ಹೆಚ್ಚು ಅನುಕೂಲಕರವಾಗಿದೆ.

ರಚನೆಯು ಪ್ರೋಗ್ರಾಂ ಕೋಡ್ ಅನ್ನು ಓದುವಂತೆ ಮಾಡುತ್ತದೆ (ಅರ್ಥವಾಗುವಂತೆ). ರಚನೆಯನ್ನು ಅರೇಗಿಂತ ಹೆಚ್ಚಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ.

ಕೆಲವು ನಿಯತಾಂಕಗಳನ್ನು ವಿವರಿಸಲು ಇದನ್ನು ಬಳಸಲಾಗುತ್ತದೆ, ಅದರಲ್ಲಿ ಸಾಕಷ್ಟು ಬಾರಿ ಇವೆ ಒಂದು ದೊಡ್ಡ ಸಂಖ್ಯೆಯಎಲ್ಲಾ ಕ್ರಮಾವಳಿಗಳಲ್ಲಿ.

ಹೆಚ್ಚುವರಿಯಾಗಿ, ಕಾರ್ಯವಿಧಾನ ಮತ್ತು ಕಾರ್ಯವು ಹೆಚ್ಚಿನ ಸಂಖ್ಯೆಯ ಪಾಸ್ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳನ್ನು ಹೊಂದಿದ್ದರೆ ರಚನೆಯನ್ನು ಬಳಸಲಾಗುತ್ತದೆ.

ನಂತರ ಎಲ್ಲಾ ನಿಯತಾಂಕಗಳನ್ನು ರಚನೆಯಲ್ಲಿ ಬರೆಯಲು ಮತ್ತು ಅದನ್ನು ರವಾನಿಸಲು ಹೆಚ್ಚು ಅನುಕೂಲಕರವಾಗಿದೆ. ಆ. ಕಾರ್ಯವಿಧಾನಗಳು ಮತ್ತು ಕಾರ್ಯಗಳ ನಿಯತಾಂಕಗಳನ್ನು "ಪ್ಯಾಕ್" ಮಾಡಲಾಗಿದೆ.

ಪ್ರತ್ಯೇಕವಾಗಿ, ಇದು ಎಂದು ಗಮನಿಸಬೇಕು ಕೀರಚನೆಯಲ್ಲಿ ಸಂಪೂರ್ಣವಾಗಿ ಯಾವುದೇ ಸಾಲು ಕಾಣಿಸುವುದಿಲ್ಲ. ಕೆಲವು ನಿರ್ಬಂಧಗಳು ಅನ್ವಯಿಸುತ್ತವೆ.

ಕೀಗುರುತಿಸುವಿಕೆಯಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸಬೇಕು. ಇದರರ್ಥ ಇನ್ ಕ್ಲ್ಯೂಚೆಯಾವುದೇ ಸ್ಥಳಾವಕಾಶಗಳು ಇರಬಾರದು ಮತ್ತು ಅದು ಸಂಖ್ಯೆಯಿಂದ ಪ್ರಾರಂಭವಾಗಬಾರದು.

ಸ್ವೀಕಾರಾರ್ಹ ಆರಂಭ ಕೀಅಕ್ಷರ ಅಥವಾ ಅಂಡರ್ಸ್ಕೋರ್ನೊಂದಿಗೆ. ಹೀಗಾಗಿ, ಕೀಗುರುತಿಸುವಿಕೆಗಳನ್ನು ರಚಿಸುವ ಅವಶ್ಯಕತೆಗಳನ್ನು ಪೂರೈಸಬೇಕು.

ರಚನೆಯು ಅರೇಯಿಂದ ಹೇಗೆ ಭಿನ್ನವಾಗಿದೆ ಎಂಬುದನ್ನು ನಾವು ಗಮನಿಸೋಣ. ರಚನೆಯಲ್ಲಿ ಒಂದು ವಿಧಾನವಿದೆ ಸೇರಿಸು, ಅರೇಯಲ್ಲಿ ಅಳವಡಿಕೆಗೆ ಎರಡು ವಿಧಾನಗಳಿವೆ: ಸೇರಿಸು(ಒಂದು ನಿರ್ದಿಷ್ಟ ಸ್ಥಾನಕ್ಕೆ) ಮತ್ತು ಸೇರಿಸಿ(ಪಟ್ಟಿಯ ಕೊನೆಯವರೆಗೆ). ಅರೇಯಲ್ಲಿ, ಎಲ್ಲಾ ಅಂಶಗಳನ್ನು ಕ್ರಮಗೊಳಿಸಲಾಗುತ್ತದೆ.

ರಚನೆಯು ಒಂದು ರೀತಿಯ ಕ್ರಮವಿಲ್ಲದ ಸೆಟ್ ಆಗಿದೆ. ಇದಕ್ಕಾಗಿಯೇ ರಚನೆಗೆ ಕೇವಲ ಒಂದು ಇನ್ಸರ್ಟ್ ವಿಧಾನವಿದೆ.

ಮೌಲ್ಯವನ್ನು ನಿರ್ದಿಷ್ಟ ಸ್ಥಾನದಲ್ಲಿ ಸೇರಿಸಲಾಗಿಲ್ಲ, ಆದರೆ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಸೆಟ್ಗೆ ಸೇರಿಸಲಾಗುತ್ತದೆ. ಇತರ ಜೆನೆರಿಕ್ ಸಂಗ್ರಹಣೆಗಳಂತೆ ಸೂಚ್ಯಂಕದಿಂದ ರಚನೆಯನ್ನು ಪ್ರವೇಶಿಸಲಾಗುವುದಿಲ್ಲ.

ರಚನೆಯ ಅಂಶಗಳನ್ನು ಕೀ ಹೆಸರಿನಿಂದ ಮಾತ್ರ ಪ್ರವೇಶಿಸಬಹುದು. ಆದಾಗ್ಯೂ, ಫಾರ್ ಪ್ರತಿ ಲೂಪ್ ಸಹ ರಚನೆಗಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ, ಆದರೆ ನೀವು ರಚನೆಯ ಅಂಶಗಳ ಕ್ರಮವನ್ನು ಅವಲಂಬಿಸಬಾರದು.

ಹೊಸ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಇತರ ಜೆನೆರಿಕ್ ಸಂಗ್ರಹಣೆಗಳ ರೀತಿಯಲ್ಲಿಯೇ ರಚನೆಯನ್ನು ರಚಿಸಲಾಗುತ್ತದೆ, ಡೇಟಾ ಪ್ರಕಾರದ ರಚನೆಯನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತದೆ.

ರಚನೆಯಂತೆ, ರಚನೆಯ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ನಿಯತಾಂಕಗಳನ್ನು ಹೊಂದಬಹುದು. ಆ. ಕನ್ಸ್ಟ್ರಕ್ಟರ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ರಚನೆಯ ವಿಷಯವನ್ನು ವಿವರಿಸಲು ಸಾಧ್ಯವಿದೆ.

ಅರೇಗಿಂತ ಭಿನ್ನವಾಗಿ, ನೀವು ಎಲ್ಲಾ ಆಯಾಮಗಳಿಗೆ ಅಂಶಗಳ ಸಂಖ್ಯೆಯನ್ನು ಸರಳವಾಗಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಬಹುದು, ರಚನೆಯಲ್ಲಿ ನೀವು ವಿಷಯವನ್ನು ಸ್ವತಃ ನಿರ್ದಿಷ್ಟಪಡಿಸಬಹುದು.

ಉದಾಹರಣೆಗೆ: OurStructure = ಹೊಸ ರಚನೆ ("ಕೋಡ್, ಹೆಸರು", 133, "Vasya");

ಅಲ್ಪವಿರಾಮದಿಂದ ಪ್ರತ್ಯೇಕಿಸಿ, ಕೀಗಳ ಹೆಸರುಗಳನ್ನು ಮೊದಲು ಪಟ್ಟಿಮಾಡಲಾಗುತ್ತದೆ, ಮತ್ತು ನಂತರ, ಅದೇ ಅನುಕ್ರಮದಲ್ಲಿ, ನಿಯತಾಂಕಗಳ ಮೌಲ್ಯಗಳು.

ರಚನೆಗೆ ಹೊಸ ಮೌಲ್ಯವನ್ನು ಸೇರಿಸಲು ಒಂದು ವಿಧಾನವಿದೆ ಸೇರಿಸು, ಇದು ಹೊಸ ಜೋಡಿಯನ್ನು ಸೇರಿಸುತ್ತದೆ (ಕೀ ಮತ್ತು ಮೌಲ್ಯ).

ಉದಾಹರಣೆಗೆ: OurStructure.Insert("ಕುಟುಂಬ ಸದಸ್ಯರು",3);

ರಚನೆಯು ಆಗಾಗ್ಗೆ ಬಳಸಲಾಗುವ ಮತ್ತೊಂದು ವಿಧಾನದಿಂದ ನಿರೂಪಿಸಲ್ಪಟ್ಟಿದೆ. ಇದು ವಿಧಾನವಾಗಿದೆ ಆಸ್ತಿ.

ಈ ವಿಧಾನವನ್ನು ಬಳಸಿಕೊಂಡು, ಕೀಲಿಯು ಅಂತಹ ಮತ್ತು ಅಂತಹ ಹೆಸರನ್ನು ಹೊಂದಿರುವ ಈ ರಚನೆಯಲ್ಲಿ ಒಂದು ಅಂಶವಿದೆಯೇ ಎಂದು ನೀವು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಬಹುದು.

ಅಂತಹ ಅಂಶವು ಅಸ್ತಿತ್ವದಲ್ಲಿದ್ದರೆ, ಸಿಸ್ಟಮ್ ಮೌಲ್ಯವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ ಸರಿ, ಇಲ್ಲದಿದ್ದರೆ - ತಪ್ಪು.

ಉದಾಹರಣೆಗೆ, ಅಭಿವ್ಯಕ್ತಿ ನಮ್ಮ ರಚನೆ.ಆಸ್ತಿ ("ಕುಟುಂಬ ಸದಸ್ಯರು")ನಿಜಕ್ಕೆ ಸಮಾನವಾಗಿರುತ್ತದೆ. ರಚನೆಯನ್ನು ವಿಶ್ಲೇಷಿಸುವಾಗ ಈ ವಿಧಾನವನ್ನು ಹೆಚ್ಚಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ.

ಯಾವುದೇ ಸಾರ್ವತ್ರಿಕ ಸಂಗ್ರಹದಂತೆ, ಸೂಚ್ಯಂಕದ ಮೂಲಕ ರಚನೆಯ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಪ್ರವೇಶಿಸಲು ಸಾಧ್ಯವಿದೆ. ಆದರೆ ರಚನೆಯ ಸೂಚ್ಯಂಕವು ಸ್ಟ್ರಿಂಗ್ ಮೌಲ್ಯವಾಗಿದೆ.

ಉದಾಹರಣೆಗೆ: ವರದಿ(ನಮ್ಮ ರಚನೆ[“ಕುಟುಂಬದ ಸದಸ್ಯರು”]);

ಆದಾಗ್ಯೂ, ರಚನೆಯು ಒಂದು ಕ್ರಮವಿಲ್ಲದ ವಸ್ತುಗಳ ಗುಂಪಾಗಿದೆ ಎಂಬುದನ್ನು ನಾವು ಮರೆಯಬಾರದು, ಅದಕ್ಕಾಗಿಯೇ ಸೂಚ್ಯಂಕ 0, 1, 2 ಮೂಲಕ ಪ್ರವೇಶಿಸುವುದು ಸ್ವೀಕಾರಾರ್ಹವಲ್ಲ.

ಜೆನೆರಿಕ್ ಸಂಗ್ರಹ ಮೌಲ್ಯಗಳ ಪಟ್ಟಿ

ಪಟ್ಟಿ ಮೌಲ್ಯಗಳುಯಾವುದೇ ಡೇಟಾ ಪ್ರಕಾರದ ಅಂಶಗಳ ರೇಖೀಯ ಪಟ್ಟಿಯಾಗಿದೆ.

ಪ್ರತಿಯೊಂದು ಅಂಶವು ಹಲವಾರು ಮೌಲ್ಯಗಳನ್ನು ಒಳಗೊಂಡಿದೆ. ಕ್ರಮಬದ್ಧವಾಗಿ, ಮೌಲ್ಯಗಳ ಪಟ್ಟಿಯನ್ನು ನಾಲ್ಕು ಕಾಲಮ್‌ಗಳೊಂದಿಗೆ ಪಟ್ಟಿಯಾಗಿ ಪ್ರತಿನಿಧಿಸಬಹುದು.

ಮೊದಲ ಅಂಕಣ - ಮಾರ್ಕ್. ಇದು ಬೂಲಿಯನ್ ಡೇಟಾ ಪ್ರಕಾರವನ್ನು ಹೊಂದಿದೆ ಮತ್ತು ಬಾಕ್ಸ್‌ಗಳನ್ನು ಚೆಕ್ ಅಥವಾ ಅನ್‌ಚೆಕ್ ಮಾಡಲು ಬಳಕೆದಾರರಿಗೆ ಅನುಮತಿಸುತ್ತದೆ.

ಇನ್ನೊಂದು ಕಾಲಮ್ ಈ ಅಂಶವನ್ನು ಹೇಗಾದರೂ ದೃಷ್ಟಿಗೋಚರವಾಗಿ ಪ್ರತಿನಿಧಿಸುವ ಚಿತ್ರವಾಗಿದೆ, ಅಂದರೆ. ಈ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಚಿತ್ರದೊಂದಿಗೆ ಹೊಂದಿಸಿ.

ಮೂರನೇ ಕಾಲಮ್ ಸಂಗ್ರಹಿತ ಮೌಲ್ಯವಾಗಿದೆ, ಅಂದರೆ. ಇದು ಯಾವುದೇ ರೀತಿಯ ಡೇಟಾ, ಮತ್ತು ಇದು ವಿಭಿನ್ನ ಸಾಲುಗಳಲ್ಲಿ ವಿಭಿನ್ನವಾಗಿರಬಹುದು.

ನಾಲ್ಕನೇ ಕಾಲಮ್ ಪ್ರಸ್ತುತಿ, ಅಂದರೆ. ಇದು ನಿರ್ದಿಷ್ಟ ಮೌಲ್ಯದ ಒಂದು ರೀತಿಯ ಸ್ಟ್ರಿಂಗ್ ವಿವರಣೆಯಾಗಿದೆ. ಬಳಕೆದಾರರು ಈ ಅಂಶವನ್ನು ವೀಕ್ಷಿಸಿದಾಗ ವೀಕ್ಷಣೆಯನ್ನು ಪ್ರದರ್ಶಿಸಲಾಗುತ್ತದೆ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಪ್ರಾತಿನಿಧ್ಯವನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸದಿದ್ದರೆ, ಈ ಸ್ಥಾನದಲ್ಲಿ ಒಳಗೊಂಡಿರುವ ಅಂಶಕ್ಕೆ ಪ್ರಾತಿನಿಧ್ಯವನ್ನು ಪಡೆಯಲು ಸಿಸ್ಟಮ್ ಪ್ರಯತ್ನಿಸುತ್ತದೆ.

ಪಟ್ಟಿ ಮೌಲ್ಯಗಳು- ಇದು ಬಳಕೆದಾರರು ದೃಷ್ಟಿಗೋಚರವಾಗಿ ಕೆಲಸ ಮಾಡಬಹುದಾದ ವಸ್ತುವಾಗಿದೆ. ಆ. ಪಟ್ಟಿ ಮೌಲ್ಯಗಳುರೂಪದಲ್ಲಿ ಪ್ರದರ್ಶಿಸಬಹುದು.

ಬಳಕೆದಾರನು ಅದರೊಂದಿಗೆ ಕೆಲವು ಕ್ರಿಯೆಗಳನ್ನು ಮಾಡಬಹುದು. ಜೊತೆಗೆ, ಪಟ್ಟಿ ಮೌಲ್ಯಗಳುವಿಧಾನಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಸ್ವತಂತ್ರವಾಗಿ ಊಹಿಸಬಹುದು, ಅಂದರೆ. ಅಲ್ಗಾರಿದಮ್‌ನ ಕೆಲವು ಶಾಖೆಯಲ್ಲಿ ಪರದೆಯ ಮೇಲೆ ತೋರಿಸು (ಹೊರತುಪಡಿಸಿ ಸರ್ವರ್ ಕೋಡ್) ಆದ್ದರಿಂದ ಬಳಕೆದಾರರು ಒಂದು ಸಾಲನ್ನು ಆಯ್ಕೆ ಮಾಡುತ್ತಾರೆ ಅಥವಾ ಕೆಲವು ಪೆಟ್ಟಿಗೆಗಳನ್ನು ಪರಿಶೀಲಿಸುತ್ತಾರೆ.

ನಾವು ಕಂಡುಕೊಳ್ಳುತ್ತೇವೆ ಪಟ್ಟಿ ಮೌಲ್ಯಗಳುಸಿಟ್ಯಾಕ್ಸ್ ಸಹಾಯಕದಲ್ಲಿ. ಕನ್ಸ್ಟ್ರಕ್ಟರ್ ಪಟ್ಟಿ ಮೌಲ್ಯಗಳುಪ್ಯಾರಾಮೀಟರ್ ಮಾಡಲಾಗಿಲ್ಲ (ನೀವು ಯಾವುದೇ ಡೀಫಾಲ್ಟ್ ಮೌಲ್ಯಗಳನ್ನು ಹೊಂದಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ).

ಅಂತಹ ವಿಧಾನಗಳಿವೆ:

• ಸೇರಿಸು(,);
• ಸೇರಿಸಿ(,);
• ಪ್ರಮಾಣ();
• ಸೂಚ್ಯಂಕ ().

ವಿಶೇಷ ವಿಧಾನಗಳೂ ಇವೆ, ಉದಾಹರಣೆಗೆ, ಅನ್‌ಲೋಡ್ ಮೌಲ್ಯಗಳು(). ಇದು ಮೌಲ್ಯಗಳ ಪಟ್ಟಿಯನ್ನು ನಕಲಿಸುವ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ರಚಿಸುತ್ತದೆ. ಉದಾಹರಣೆಗೆ:

ಅಂಶಗಳ ಅರೇ = ಬೆಲೆ ಪ್ರಕಾರಗಳ ಪಟ್ಟಿ.ಔಟ್‌ಲೋಡ್ ಮೌಲ್ಯಗಳು();

ರಿವರ್ಸ್ ವಿಧಾನವೂ ಇದೆ:
ListPriceTypes.LoadValues(ArrayItems);

ಹುಡುಕಾಟ ವಿಧಾನಗಳಿವೆ:
FindByValue(); FindByIdentifier().

ನಕಲು ವಿಧಾನವಿದೆ:
ListCopy = PriceTypeList.Copy();
ಈ ವಿಧಾನಪ್ರತಿಗೆ ಕೆಲವು ರೀತಿಯ ಮಾರ್ಪಾಡು ಮಾಡಲು ಉದ್ದೇಶಿಸಲಾಗಿದೆ.

ವಿಧಾನಗಳಿವೆ:
SortByValue();
SortByView().

ವಿಧಾನಗಳು ಐಟಂ ಆಯ್ಕೆ(,)ಮತ್ತು ಮಾರ್ಕ್ಐಟಮ್ಸ್()ಬಳಕೆದಾರರು ವಿಂಡೋವನ್ನು ಮುಚ್ಚುವವರೆಗೆ ಅಲ್ಗಾರಿದಮ್‌ನ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯನ್ನು ನಿಲ್ಲಿಸುವ ಮೋಡಲ್ ಡೈಲಾಗ್ ಬಾಕ್ಸ್ ಅನ್ನು ಕರೆ ಮಾಡಿ.

ಕಾನ್ಫಿಗರೇಶನ್ ಗುಣಲಕ್ಷಣಗಳಲ್ಲಿ ಈ ವಿಧಾನಗಳನ್ನು ಬಳಸಲು ವಿಧಾನವನ್ನು ಬಳಸುವ ವಿಧಾನಗೆ ಹೊಂದಿಸಬೇಕು ಬಳಸಿ.

ನಿರ್ವಹಿಸಿದ ಅಪ್ಲಿಕೇಶನ್ ಮಾಡ್ಯೂಲ್‌ನಿಂದ ಕರೆಯಲಾದ ಉದಾಹರಣೆ ಕೋಡ್:

ಈ ಕೋಡ್ ಅನ್ನು ಬಳಕೆದಾರ ಮೋಡ್‌ನಲ್ಲಿ ಪ್ರದರ್ಶಿಸಿ (ಮೋಡಲ್ ಡೈಲಾಗ್).

ಕೆಳಗೆ ಪಟ್ಟಿ ಮೌಲ್ಯಗಳುಫಾರ್ಮ್ ಗುಣಲಕ್ಷಣಗಳಿಗಾಗಿ ಲಭ್ಯವಿರುವ ಡೇಟಾ ಪ್ರಕಾರವಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ. ನಾವು ಸಂಸ್ಕರಣಾ ಫಾರ್ಮ್‌ಗಾಗಿ ಹೊಸ ಗುಣಲಕ್ಷಣವನ್ನು ರಚಿಸುತ್ತೇವೆ ಮತ್ತು ಅದರ ಪ್ರಕಾರವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತೇವೆ ಪಟ್ಟಿ ಮೌಲ್ಯಗಳುಮತ್ತು ಅದನ್ನು ಫಾರ್ಮ್‌ನಲ್ಲಿ ಪ್ರದರ್ಶಿಸಿ.

ನಾವು ರಚಿಸುತ್ತೇವೆ ಹೊಸ ತಂಡ ಉಡುಗೊರೆಗಳನ್ನು ಸೈನ್ ಅಪ್ ಮಾಡಿ, ಅದನ್ನು ಫಾರ್ಮ್‌ಗೆ ವರ್ಗಾಯಿಸಿ ಮತ್ತು ಅದಕ್ಕೆ ಆಕ್ಷನ್ ಹ್ಯಾಂಡ್ಲರ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಿ.

ಬಳಕೆದಾರ ಮೋಡ್‌ನಲ್ಲಿ, ನೀವು ಸಂಸ್ಕರಣಾ ಫಾರ್ಮ್‌ನಲ್ಲಿ ಫಿಲ್ ಇನ್ ಗಿಫ್ಟ್ಸ್ ಬಟನ್ ಅನ್ನು ಕ್ಲಿಕ್ ಮಾಡಿದಾಗ, ಪೂರ್ಣಗೊಂಡ ಪಟ್ಟಿಯು ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತದೆ.

ಬಯಸಿದಲ್ಲಿ, ಪಟ್ಟಿಯನ್ನು ಸಂಪಾದಿಸಬಹುದು: ಕೆಲವು ಅಂಶಗಳನ್ನು ಸೇರಿಸಬಹುದು, ಕೆಲವು ತೆಗೆದುಹಾಕಬಹುದು.

ಬಹುಮುಖ ಸಂಗ್ರಹಣೆ ಅನುಸರಣೆ

ಈ ಸಂಗ್ರಹವು ತುಂಬಾ ಹೋಲುತ್ತದೆ ರಚನೆ. ರಚನೆಯಂತೆಯೇ, ಮ್ಯಾಪಿಂಗ್‌ಗಳು ಕೀ ಮತ್ತು ಮೌಲ್ಯವನ್ನು ಒಳಗೊಂಡಿರುವ ಮೌಲ್ಯಗಳ ಸೆಟ್ಗಳಾಗಿವೆ.

ಮುಖ್ಯ ವ್ಯತ್ಯಾಸವೆಂದರೆ ಯಾವುದೇ ಡೇಟಾ ಪ್ರಕಾರವನ್ನು ಕೀ ಎಂದು ನಿರ್ದಿಷ್ಟಪಡಿಸಬಹುದು, ಹಾಗೆಯೇ ಮೌಲ್ಯಕ್ಕಾಗಿ. ಈ ವೈಶಿಷ್ಟ್ಯದ ದೃಷ್ಟಿಯಿಂದ, ಸೂಚ್ಯಂಕದಿಂದ ಹೊಂದಾಣಿಕೆಯ ಮೌಲ್ಯವನ್ನು ಪ್ರವೇಶಿಸುವುದು ಅವಶ್ಯಕವಾಗಿದೆ;

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

ಅನುಸರಣೆ ಕನ್ಸ್ಟ್ರಕ್ಟರ್, ರಚನೆಯಂತಲ್ಲದೆ, ನಿಯತಾಂಕಗಳನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುವ ಸಾಮರ್ಥ್ಯವನ್ನು ಹೊಂದಿರುವುದಿಲ್ಲ.

ಬಳಕೆಯ ಉದಾಹರಣೆ:

ನೀವು ಯಾವುದೇ ಎರಡು ರಚನೆಗಳನ್ನು ಸಂಪರ್ಕಿಸಬೇಕಾದಾಗ ಪತ್ರವ್ಯವಹಾರವು ಬಳಸಲು ಅನುಕೂಲಕರವಾಗಿದೆ. ಉದಾಹರಣೆಗೆ, ಕೋಷ್ಟಕ ಭಾಗದ ಪ್ರತಿಯೊಂದು ಸಾಲು ಮೌಲ್ಯಗಳ ಕೋಷ್ಟಕದಿಂದ ಸಾಲಿಗೆ ಹೊಂದಿಕೆಯಾಗಬೇಕು.
ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಟೇಬಲ್ ವಿಭಾಗದ ಸಾಲನ್ನು ಪಂದ್ಯದ ಕೀಲಿಯಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ ಮತ್ತು ಅನುಗುಣವಾದ ಮೌಲ್ಯವನ್ನು ಸೂಚಿಸಲಾಗುತ್ತದೆ.

ವಿಧಾನದ ಜೊತೆಗೆ ಸಂಗ್ರಹಣೆಯಲ್ಲಿ ಅಂಶಗಳನ್ನು ಸೇರಿಸುವಾಗ ಹೊಂದಾಣಿಕೆ ಸೇರಿಸಿ(,)ಮೌಲ್ಯವನ್ನು ಸೇರಿಸಲು ಇನ್ನೊಂದು ಮಾರ್ಗವೆಂದರೆ ನಿಯಮಿತ ನಿಯೋಜನೆ ಆಪರೇಟರ್ ಅನ್ನು ಬಳಸುವುದು.

ಉದಾಹರಣೆಗೆ: OurMatch = NewMatch;
ಪಂದ್ಯ = 999;

ಆ. ಸಂಗ್ರಹಣೆಯಲ್ಲಿ ಒಂದು ಅಂಶ ಇಲ್ಲದಿದ್ದರೆ, ಅದನ್ನು ಕಾರ್ಯನಿಯೋಜನೆ ಆಪರೇಟರ್ ಬಳಸಿ ಸೇರಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಅದು ಇದ್ದಲ್ಲಿ ಅದನ್ನು ನವೀಕರಿಸಲಾಗುತ್ತದೆ.

ಇದು ರಚನೆಗೆ ವಿರುದ್ಧವಾಗಿದೆ.

ಮೌಲ್ಯಗಳ ಯುನಿವರ್ಸಲ್ ಕಲೆಕ್ಷನ್ ಟೇಬಲ್

ಮೌಲ್ಯಗಳ ಕೋಷ್ಟಕಅನಿಯಂತ್ರಿತ ಸಂಖ್ಯೆಯ ಸಾಲುಗಳು ಮತ್ತು ಅನಿಯಂತ್ರಿತ ಸಂಖ್ಯೆಯ ಕಾಲಮ್‌ಗಳನ್ನು ಹೊಂದಿರುವ ಕೋಷ್ಟಕವಾಗಿದೆ. ಛೇದಕವು ಯಾವುದೇ ಡೇಟಾ ಪ್ರಕಾರದ ಮೌಲ್ಯಗಳನ್ನು ಸಂಗ್ರಹಿಸಬಹುದು. ಅಗತ್ಯವಿದ್ದರೆ, ಕಾಲಮ್ಗಳನ್ನು ಟೈಪ್ ಮಾಡಬಹುದು, ಅಂದರೆ, ಯಾವ ಕಾಲಮ್ನಲ್ಲಿ ಯಾವ ರೀತಿಯ ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸಲಾಗಿದೆ ಎಂಬುದನ್ನು ನೀವು ನಿರ್ಧರಿಸಬಹುದು.

ನೀವು ಕಾಲಮ್‌ಗಳನ್ನು ಟೈಪ್ ಮಾಡದೆ ಬಿಡಬಹುದು, ನಂತರ ವಿವಿಧ ರೀತಿಯ ಮೌಲ್ಯಗಳನ್ನು ವಿವಿಧ ಸಾಲುಗಳಲ್ಲಿ ಒಂದು ಕಾಲಮ್‌ನಲ್ಲಿ ಸಂಗ್ರಹಿಸಬಹುದು.

ವ್ಯತ್ಯಾಸಗಳು ಮೌಲ್ಯ ಕೋಷ್ಟಕಗಳುಎರಡು ಆಯಾಮದ ರಚನೆಯಿಂದ:

• ಇದು ಬಳಕೆದಾರರು ಕೆಲಸ ಮಾಡಬಹುದಾದ ವಸ್ತುವಾಗಿದೆ (ಮೌಲ್ಯಗಳ ಕೋಷ್ಟಕವನ್ನು ಪರದೆಯ ಮೇಲೆ ಪ್ರದರ್ಶಿಸಬಹುದು, ಬಳಕೆದಾರರು ಅದನ್ನು ಭರ್ತಿ ಮಾಡಬಹುದು ಮತ್ತು ನಮೂದಿಸಿದ ಡೇಟಾವನ್ನು ನಂತರ ಓದಬಹುದು);
• ತ್ವರಿತ ಹುಡುಕಾಟಕ್ಕಾಗಿ ಸೂಚ್ಯಂಕಗಳನ್ನು ನಿರ್ಮಿಸುವುದು;
• ಕ್ಲೋನಿಂಗ್, ಒಂದು ನಿರ್ದಿಷ್ಟ ಮೌಲ್ಯದೊಂದಿಗೆ ಸಂಪೂರ್ಣ ಕಾಲಮ್ ಅನ್ನು ತುಂಬುವುದು, ಎಲ್ಲಾ ಕಾಲಮ್‌ಗಳನ್ನು ಒಂದು ಶ್ರೇಣಿಗೆ ಇಳಿಸುವುದು.

ಮೌಲ್ಯಗಳ ಕೋಷ್ಟಕಒಂದು ರೀತಿಯ ಮಾಹಿತಿ ಶೇಖರಣಾ ಬಫರ್ ಆಗಿ ಬಳಸಲಾಗುತ್ತದೆ. ಮೌಲ್ಯಗಳ ಕೋಷ್ಟಕಅನೇಕ ಸಿಸ್ಟಮ್ ವಿಧಾನಗಳಿಂದ ಹಿಂತಿರುಗಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಪ್ಯಾರಾಮೀಟರ್ ಆಗಿ ಸ್ವೀಕರಿಸಲಾಗುತ್ತದೆ. ಮೌಲ್ಯಗಳ ಕೋಷ್ಟಕದ ವಿರುದ್ಧ ಪ್ರಶ್ನೆಯನ್ನು ನಿರ್ಮಿಸಲು ಸಾಧ್ಯವಿದೆ.

ಆದ್ದರಿಂದ, ಮೌಲ್ಯಗಳ ಕೋಷ್ಟಕಸಾಲುಗಳ ಗುಂಪನ್ನು ಮತ್ತು ಕಾಲಮ್ಗಳ ಗುಂಪನ್ನು ಒಳಗೊಂಡಿದೆ. ಸಾಲುಗಳು ಮತ್ತು ಕಾಲಮ್‌ಗಳೆರಡೂ ಸಂಗ್ರಹಗಳಾಗಿವೆ.

ಆ. ಸಂಗ್ರಹದ ಒಳಗೆ ಮೌಲ್ಯಗಳ ಕೋಷ್ಟಕಇನ್ನೂ ಎರಡು ಸಂಗ್ರಹಗಳಿವೆ. ನಾವು ಸಿಂಟ್ಯಾಕ್ಸ್ ಸಹಾಯಕಕ್ಕೆ ತಿರುಗೋಣ ಮತ್ತು ಕಂಡುಹಿಡಿಯೋಣ ಮೌಲ್ಯಗಳ ಕೋಷ್ಟಕ.

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

ಪ್ರಮುಖ ಅಂಶ! ರಚಿಸುವ ಕಾರ್ಯವಿಧಾನ ಮೌಲ್ಯಗಳ ಕೋಷ್ಟಕ, &OnServer ಅನ್ನು ಕಂಪೈಲ್ ಮಾಡಬೇಕು.

ನೀವು ಕೆಲಸ ಮಾಡಲು ಪ್ರಾರಂಭಿಸುವ ಮೊದಲು ಮೌಲ್ಯಗಳ ಕೋಷ್ಟಕ, ಅದು ಯಾವ ಕಾಲಮ್‌ಗಳನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ ಎಂಬುದನ್ನು ನೀವು ನಿರ್ಧರಿಸಬೇಕು (ಅಂದರೆ ಅವುಗಳನ್ನು ರಚಿಸಿ). ವಾಕ್ಯ ರಚನೆ:

ಸೇರಿಸಿ(,)
(ಐಚ್ಛಿಕ)
ಪ್ರಕಾರ: ಸ್ಟ್ರಿಂಗ್.
(ಐಚ್ಛಿಕ)
ಪ್ರಕಾರ: ವಿವರಣೆ ಪ್ರಕಾರಗಳು
(ಐಚ್ಛಿಕ)
ಪ್ರಕಾರ: ಸ್ಟ್ರಿಂಗ್.
(ಐಚ್ಛಿಕ)
ಪ್ರಕಾರ: ಸಂಖ್ಯೆ.

ಉದಾಹರಣೆಗೆ:

ಈ ವಿಧಾನವನ್ನು ಕರೆಯಲು ನಾವು ಆಜ್ಞೆಯನ್ನು ಬಳಸುತ್ತೇವೆ.

ವಿವರಣೆಯಲ್ಲಿ ಮೌಲ್ಯ ಕೋಷ್ಟಕಗಳುಸಂಗ್ರಹದ ಅಂಶಗಳು ನಿಖರವಾಗಿವೆ ರೋಸ್ಟೇಬಲ್ ಮೌಲ್ಯಗಳು.

ಕಾಲಮ್‌ಗಳಿಗಿಂತ ಭಿನ್ನವಾಗಿ, ಇದು ಗುಣಲಕ್ಷಣಗಳನ್ನು ಮಾತ್ರ ಒಳಗೊಂಡಿರುತ್ತದೆ (ಹೆಸರು, ಪ್ರಕಾರ, ಶಿರೋನಾಮೆ, ಅಗಲ), ರೋಟೇಬಲ್ ಮೌಲ್ಯಗಳುಎರಡೂ ಗುಣಲಕ್ಷಣಗಳಿವೆ (ಕಾಲಮ್ ಹೆಸರಿನ ಮೂಲಕ ಪ್ರವೇಶ) ಮತ್ತು ವಿಧಾನಗಳು (ನೀವು ಮೌಲ್ಯವನ್ನು ಪಡೆಯಬಹುದು ಮತ್ತು ಹೊಂದಿಸಬಹುದು, ಮಾಲೀಕರೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಬಹುದು).

ಕೂಡಿಸಲು ಹೊಸ ಗೆರೆಟೇಬಲ್ಗೆ ನೀವು ವಿಧಾನವನ್ನು ಬಳಸಬೇಕಾಗುತ್ತದೆ ಸೇರಿಸಿ(), ಅಥವಾ ಸೇರಿಸು(). ಎರಡನೆಯ ಸಂದರ್ಭದಲ್ಲಿ, ಅಗತ್ಯವಿರುವ ರೇಖೆಯನ್ನು ಯಾವ ಸ್ಥಾನದಲ್ಲಿ ಇರಿಸಬೇಕು ಎಂಬುದನ್ನು ನೀವು ಸೂಚಿಸಬೇಕು.

ಕಾಲಮ್‌ಗೆ ಮೌಲ್ಯವನ್ನು ನಿಯೋಜಿಸಲು, ಕಾಲಮ್ ಹೆಸರು ಅಥವಾ ಸೂಚಿಯನ್ನು ಪ್ರವೇಶಿಸಲು ನಾವು ಡಾಟ್ ಅನ್ನು ಬಳಸುತ್ತೇವೆ (ಚದರ ಆವರಣಗಳನ್ನು ಬಳಸಿ).

ಭರ್ತಿ ಮಾಡಲು ಮೌಲ್ಯ ಕೋಷ್ಟಕಗಳುಕೆಳಗಿನ ವಿಧಾನಗಳನ್ನು ಬಳಸಬಹುದು:

ಸ್ಪಷ್ಟ()- ಎಲ್ಲಾ ಸಾಲುಗಳನ್ನು ತೆಗೆದುಹಾಕಲು ಮೌಲ್ಯ ಕೋಷ್ಟಕಗಳು.

ಭರ್ತಿ ಮೌಲ್ಯಗಳು(,)- ಎಲ್ಲಾ ಕಾಲಮ್‌ಗಳು ಅಥವಾ ಆಯ್ದ ಕಾಲಮ್‌ಗಳನ್ನು ಒಂದು ಮೌಲ್ಯದೊಂದಿಗೆ ತುಂಬಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.
ಲೋಡ್ ಕಾಲಮ್(,)- ರಚನೆಯಿಂದ ಕಾಲಮ್ ಅನ್ನು ಲೋಡ್ ಮಾಡುತ್ತದೆ.
ಅನ್‌ಲೋಡ್ ಕಾಲಮ್()- ಒಂದು ಶ್ರೇಣಿಗೆ ಕಾಲಮ್ ಅನ್ನು ಇಳಿಸುತ್ತದೆ.

ನೀವು ಒಂದು ಮೌಲ್ಯದ ಕೋಷ್ಟಕದಿಂದ ಇನ್ನೊಂದಕ್ಕೆ ಕಾಲಮ್ ಅನ್ನು ವರ್ಗಾಯಿಸಬೇಕಾದಾಗ ಕೊನೆಯ ಎರಡು ವಿಧಾನಗಳು ಬಳಸಲು ಅನುಕೂಲಕರವಾಗಿದೆ.

ನಕಲು(,)- ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಕೋಷ್ಟಕವನ್ನು ಆಧರಿಸಿ ಹೊಸದನ್ನು ರಚಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ ಮೌಲ್ಯಗಳ ಕೋಷ್ಟಕ, ಮತ್ತು ಎಲ್ಲಾ ಸಾಲುಗಳು ಮತ್ತು ಎಲ್ಲಾ ಕಾಲಮ್‌ಗಳು ಅಲ್ಲ, ಆದರೆ ಅವುಗಳಲ್ಲಿ ಕೆಲವು ಮಾತ್ರ. ರಿಟರ್ನ್ ಮೌಲ್ಯ - ಮೌಲ್ಯಗಳ ಕೋಷ್ಟಕ.

ನೀವು ರಚನೆಯನ್ನು ನಕಲಿಸಬಹುದು ಮೌಲ್ಯ ಕೋಷ್ಟಕಗಳು. ಇದಕ್ಕೆ ಅನುಗುಣವಾದ ವಿಧಾನವಿದೆ ಕಾಪಿಕಾಲಮ್‌ಗಳು(). ನಾವು ಖಾಲಿ ಒಂದನ್ನು ಪಡೆಯುತ್ತೇವೆ ಮೌಲ್ಯಗಳ ಕೋಷ್ಟಕಅಗತ್ಯವಿರುವ ರಚನೆಯೊಂದಿಗೆ.

IN ಮೌಲ್ಯಗಳ ಕೋಷ್ಟಕಒಂದು ವಿಧಾನವಿದೆ ಒಟ್ಟು(). ನೀವು ಸಂಖ್ಯಾತ್ಮಕ ಮೌಲ್ಯಗಳನ್ನು ಒಟ್ಟುಗೂಡಿಸಲು ಬಯಸುವ ಕಾಲಮ್ ಅನ್ನು ನೀವು ನಿರ್ದಿಷ್ಟಪಡಿಸಬಹುದು. ಕೋಷ್ಟಕದಲ್ಲಿ ಹಿಂದೆ ತೋರಿಸಿದ ಕೋಡ್‌ಗೆ ಸಂಬಂಧಿಸಿದಂತೆ, ನೀವು ಮೌಲ್ಯವನ್ನು ಲೆಕ್ಕ ಹಾಕಬಹುದು: TK. ಒಟ್ಟು ("ಮೊತ್ತ").

IN ಮೌಲ್ಯಗಳ ಕೋಷ್ಟಕವಿಧಾನವನ್ನು ಬಳಸಿಕೊಂಡು ಕೆಲವು ಕಾಲಮ್‌ಗಳ ಒಂದೇ ಮೌಲ್ಯಗಳಿಂದ ಸಂಖ್ಯಾತ್ಮಕ ಮೌಲ್ಯಗಳನ್ನು ಗುಂಪು ಮಾಡಲು (ಕುಗ್ಗಿಸಲು) ಸಾಧ್ಯವಿದೆ ಕುಗ್ಗಿಸು(,).

ಕೋಷ್ಟಕದಲ್ಲಿ ಹಿಂದೆ ತೋರಿಸಿದ ಕೋಡ್‌ಗೆ ಸಂಬಂಧಿಸಿದಂತೆ, ನೀವು ಮೌಲ್ಯವನ್ನು ಲೆಕ್ಕ ಹಾಕಬಹುದು: TK.Collapse("ವಾರದ ದಿನ", "ಮೊತ್ತ").

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

ಪ್ರದರ್ಶಿಸಲು ಮೌಲ್ಯಗಳ ಕೋಷ್ಟಕಪರದೆಯ ಮೇಲೆ, ಫಾರ್ಮ್ ಗುಣಲಕ್ಷಣವನ್ನು ರಚಿಸಿ ಮತ್ತು ಅದಕ್ಕೆ ಡೇಟಾ ಪ್ರಕಾರವನ್ನು ನಿಯೋಜಿಸಿ ಮೌಲ್ಯಗಳ ಕೋಷ್ಟಕ.

ಅದರ ನಂತರ, ಪರಿಣಾಮವಾಗಿ ಟೇಬಲ್ ಅನ್ನು ಫಾರ್ಮ್ನಲ್ಲಿ ಪ್ರದರ್ಶಿಸಬೇಕು.

ಹಿಂದೆ ಕಂಪೈಲ್ ಮಾಡಿದ ಅಲ್ಗಾರಿದಮ್‌ನ ಕೊನೆಯಲ್ಲಿ ಫಾರ್ಮ್ ಮಾಡ್ಯೂಲ್‌ನಲ್ಲಿ (ಮೌಲ್ಯ ಕೋಷ್ಟಕವನ್ನು ರಚಿಸುವ ಕಾರ್ಯವಿಧಾನದಲ್ಲಿ), ನೀವು ಸೇರಿಸಬೇಕು:
ValueInFormData(TK, ಟೇಬಲ್);

ಯುನಿವರ್ಸಲ್ ಸಂಗ್ರಹ ಮೌಲ್ಯಗಳ ಮರ

ಒಂದು ಸಾರ್ವತ್ರಿಕ ಸಂಗ್ರಹವು ಹೋಲುತ್ತದೆ ಮೌಲ್ಯಗಳ ಕೋಷ್ಟಕ. ಮೇಜಿನಿಂದ ವ್ಯತ್ಯಾಸವೆಂದರೆ ಮರದ ಸಾಲುಗಳು ಪರಸ್ಪರ ಅಧೀನವಾಗಬಹುದು, ಅಂದರೆ. ಕೆಲವು ರೀತಿಯ ಶ್ರೇಣಿಯನ್ನು ರಚಿಸಬಹುದು.

ಇದು ಪರದೆಯ ಮೇಲೂ ಪ್ರತಿಫಲಿಸಬಹುದು. ಮೌಲ್ಯದ ಮರವು ಸ್ಪಷ್ಟವಾಗಿ ಸಾಲುಗಳ ಸಂಗ್ರಹ ಮತ್ತು ಕಾಲಮ್‌ಗಳ ಸಂಗ್ರಹವನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ. ಮರದಲ್ಲಿ ಎರಡು ಗುಣಲಕ್ಷಣಗಳಿವೆ: ಸಾಲುಗಳು ಮತ್ತು ಕಾಲಮ್ಗಳು.

ಸಾಲುಗಳು ಒಂದಕ್ಕೊಂದು ಅಧೀನವಾಗಿರುವುದರಿಂದ, ಪ್ರತಿ ಸಾಲು ಪೋಷಕರನ್ನು ಮತ್ತು ಅದರ ಅಧೀನ ಸಾಲುಗಳನ್ನು ಹೊಂದಿರಬಹುದು.

ಅನುಗುಣವಾದ ಟ್ರೀ ಆಜ್ಞೆಯನ್ನು ಮತ್ತು ಅದರ ಸಂಸ್ಕರಣಾ ವಿಧಾನವನ್ನು ರಚಿಸೋಣ.

ರಚಿಸೋಣ ಇದರಲ್ಲಿ ಒಂದು ಪೋಷಕ ಸಾಲು ಮತ್ತು ಎರಡು ಅಧೀನ ಸಾಲುಗಳಿವೆ.

ಫಾರ್ಮ್ ಗುಣಲಕ್ಷಣಗಳನ್ನು ರಚಿಸೋಣ DerZn(ಡೇಟಾ ಪ್ರಕಾರ - ಮೌಲ್ಯಗಳ ಮರ).

ಈ ಗುಣಲಕ್ಷಣಕ್ಕಾಗಿ, ನಾವು ವರ್ಷ ಮತ್ತು ತಿಂಗಳ ಕಾಲಮ್‌ಗಳನ್ನು ರಚಿಸುತ್ತೇವೆ.

ಅನುಗುಣವಾದ ಅಂಶವನ್ನು ಸರಿಸಿ DerZnರೂಪದಲ್ಲಿ.

ಕೊನೆಯಲ್ಲಿ ಕಾರ್ಯವಿಧಾನಗಳು TreeOnServer()ಸೇರಿಸೋಣ:

ValueInFormData(TreeZn, DerZn);

ಬಳಕೆದಾರ ಮೋಡ್‌ನಲ್ಲಿ ಏನಾಯಿತು ಎಂಬುದನ್ನು ಪರಿಶೀಲಿಸೋಣ.

ಒಂದು ಗುಂಡಿಯನ್ನು ಬಳಸುವುದು ಸೇರಿಸಿನೀವು ಹೊಸ ಸಾಲುಗಳನ್ನು ಸೇರಿಸಬಹುದು. ಅವರು ಕ್ರಮಾನುಗತವನ್ನು ಸಹ ರಚಿಸಬಹುದು.

ಮೌಲ್ಯದ ಮರದ ಎಲ್ಲಾ ಅಂಶಗಳನ್ನು ಹಾದುಹೋಗಲು, ನಾವು ಪುನರಾವರ್ತನೆಯನ್ನು ಬಳಸಬೇಕಾಗುತ್ತದೆ, ಅಂದರೆ. ಸ್ವತಃ ಕಾರ್ಯವಿಧಾನವನ್ನು ಕರೆಯುವುದು. ಉದಾಹರಣೆಗೆ, ಮೌಲ್ಯದ ಮರವನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವುದು ಈ ರೀತಿ ಕಾಣಿಸಬಹುದು:

ಇದು ಸಾರ್ವತ್ರಿಕ ಸಂಗ್ರಹಣೆಗಳೊಂದಿಗೆ ನಮ್ಮ ಮೊದಲ ಪರಿಚಯವನ್ನು ಮುಕ್ತಾಯಗೊಳಿಸುತ್ತದೆ.

ಪ್ರೋಗ್ರಾಂ ಕೋಡ್‌ನಿಂದ ಡೈರೆಕ್ಟರಿ ಅಂಶಕ್ಕೆ ಪ್ರವೇಶವನ್ನು ಸರಳಗೊಳಿಸಲು ಡೆವಲಪರ್ ಯಾವ ಪ್ರಮುಖ ಕಾರ್ಯವಿಧಾನವನ್ನು ಬಳಸಬಹುದು ಎಂಬುದನ್ನು ಮುಂದಿನ ಲೇಖನದಲ್ಲಿ ನಾವು ನೋಡುತ್ತೇವೆ.

ಈ ಘಟಕದಲ್ಲಿ ನಾವು 1C ಭಾಷೆಯ ಹೊಸ ಡೇಟಾ ಪ್ರಕಾರದೊಂದಿಗೆ ಪರಿಚಯ ಮಾಡಿಕೊಳ್ಳುತ್ತೇವೆ, ಅದನ್ನು ಕರೆಯಲಾಗುತ್ತದೆ ಪಟ್ಟಿ ಮೌಲ್ಯಗಳು.

ಮೌಲ್ಯಗಳ ಪಟ್ಟಿಒಂದು ಶ್ರೇಣಿಯಾಗಿದೆ, ಆದರೆ ಉತ್ತಮ ಸಾಮರ್ಥ್ಯಗಳೊಂದಿಗೆ. ಮತ್ತು ಹಾಗಿದ್ದಲ್ಲಿ, ಅದು ಡೇಟಾದ ಸಂಗ್ರಹವಾಗಿದೆ ಮತ್ತು ನೀವು ಅದರಲ್ಲಿ ಸಂಖ್ಯೆಗಳ ಗುಂಪನ್ನು ಹಾಕಬಹುದು:

// ಮೌಲ್ಯಗಳ ಪಟ್ಟಿಯನ್ನು ರಚಿಸಲಾಗಿದೆ

ಪಟ್ಟಿ ಸೇರಿಸಿ (23);

ಇಲ್ಲಿಯವರೆಗೆ ಎಲ್ಲವೂ ಒಂದು ಶ್ರೇಣಿಯಂತೆ ಕಾಣುತ್ತದೆ, ಅಲ್ಲವೇ? ಆದರೆ ಮುಂದೆ ಹೋಗೋಣ. ಈಗ ಈ ಸಂಖ್ಯೆಗಳನ್ನು ಬಳಕೆದಾರರಿಗೆ ಪ್ರದರ್ಶಿಸಲು, ನಾವು ಬರೆಯುತ್ತೇವೆ:

// ಪಟ್ಟಿಯ ಪ್ರತಿಯೊಂದು ಅಂಶದ ಮೂಲಕ ಲೂಪ್ ಪಟ್ಟಿ ಲೂಪ್ ವರದಿ (Element.Value);

// ಎಂಡ್‌ಸೈಕಲ್ ಅಂಶದ ಮೌಲ್ಯವನ್ನು ಪ್ರದರ್ಶಿಸಿ;

ಮತ್ತು ಇಲ್ಲಿ ಮೊದಲ ವ್ಯತ್ಯಾಸವಿದೆ. ನಿಯಮಿತ ರಚನೆಯ ಅಂಶಗಳು ಸಂಖ್ಯೆಗಳೇ ಆಗಿರುತ್ತವೆ. ಮತ್ತು ಒಂದು ಅಂಶದ ಪ್ರಸ್ತುತ ಮೌಲ್ಯಕ್ಕೆ ಪ್ರವೇಶ ಪಟ್ಟಿನಾವು ಆಯ್ಕೆಯನ್ನು ಬಳಸುತ್ತೇವೆ ಅರ್ಥ, ನಿರ್ಮಾಣವನ್ನು ಬಳಸುವುದು ಅಂಶ. ಅರ್ಥ.

ಕೆಲವು ಹೆಚ್ಚುವರಿ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ನೋಡೋಣ ಮೌಲ್ಯಗಳನ್ನು.

ವಿಂಗಡಿಸಬಹುದು

ಉದಾಹರಣೆಗೆ, ನಾವು ಮೌಲ್ಯಗಳ ಪಟ್ಟಿಯನ್ನು ಸುಲಭವಾಗಿ ವಿಂಗಡಿಸಬಹುದು. ಪಟ್ಟಿಯು ಇದನ್ನು ಸ್ವತಃ ಮಾಡಬಹುದು:

ಪಟ್ಟಿ.SortByValue(SortDirection.Age); ಸಾಮಾನ್ಯ ರಚನೆಯ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ವಿಂಗಡಣೆ ಅಲ್ಗಾರಿದಮ್‌ಗಳಲ್ಲಿ ಒಂದನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಬೇಕಾಗುತ್ತದೆ (ಉದಾಹರಣೆಗೆ, "ಬಬಲ್").

ಹುಡುಕಬಹುದು

ಮೌಲ್ಯಗಳ ಪಟ್ಟಿಯು ತನ್ನದೇ ಆದ ಅಂಶಗಳನ್ನು ಹುಡುಕಬಹುದು. ಬಳಕೆದಾರರು ನಮೂದಿಸಿದ ಸಂಖ್ಯೆಯು ನಮ್ಮ ಪಟ್ಟಿಯಲ್ಲಿದೆಯೇ ಎಂದು ಕಂಡುಹಿಡಿಯಲು ನಾವು ಬಯಸುತ್ತೇವೆ ಎಂದು ಹೇಳೋಣ:

EnterNumber(ಸಂಖ್ಯೆ); // ಬಳಕೆದಾರರಿಂದ ಸಂಖ್ಯೆಯನ್ನು ನಮೂದಿಸಲಾಗಿದೆ FoundElement = ಪಟ್ಟಿ. FindByValue (ಸಂಖ್ಯೆ);

FoundItem = ವ್ಯಾಖ್ಯಾನಿಸದಿದ್ದರೆ ನಂತರ OpenValue("ಸಂಖ್ಯೆ " + ಸಂಖ್ಯೆ + "ಪಟ್ಟಿಯಲ್ಲಿ ಕಂಡುಬಂದಿಲ್ಲ!"); ಇಲ್ಲದಿದ್ದರೆ

OpenValue("ಸಂಖ್ಯೆ " + ಸಂಖ್ಯೆ + " ಪಟ್ಟಿಯಲ್ಲಿದೆ. ಅದು ಇಲ್ಲಿದೆ:" + FoundElement.Value);

ಕೊನೆಯಲ್ಲಿ ವೇಳೆ; ಪಟ್ಟಿ ಮೌಲ್ಯಗಳು

ಅಳವಡಿಕೆ ಮತ್ತು ಅಳಿಸುವಿಕೆಯನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ

ರಚನೆಯಂತಹ ಮೌಲ್ಯಗಳ ಪಟ್ಟಿಯು ಅಂಶಗಳ ಅಳವಡಿಕೆ ಮತ್ತು ತೆಗೆದುಹಾಕುವಿಕೆಯನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ:

ಪಟ್ಟಿ. ಸೇರಿಸಿ (0, 1000);

// ಪಟ್ಟಿಯ ಪ್ರಾರಂಭದಲ್ಲಿಯೇ ಸಾವಿರವನ್ನು ಸೇರಿಸಿ. ಅಳಿಸು(O); // ಮತ್ತು ತಕ್ಷಣ ಅದನ್ನು ಪಟ್ಟಿ ಪಟ್ಟಿಯಿಂದ ತೆಗೆದುಹಾಕಿ. ಸೇರಿಸು(ಪಟ್ಟಿ.ಪ್ರಮಾಣ(), 13);

// ಪಟ್ಟಿಯ ಕೊನೆಯಲ್ಲಿ 13 ಅನ್ನು ಸೇರಿಸಿ ವರದಿ (ಪಟ್ಟಿ[List.Quantity() - 1]);

// ಪಟ್ಟಿಯ ಕೊನೆಯ ಅಂಶವನ್ನು ಪ್ರದರ್ಶಿಸಿ (13)

ಚದರ ಆವರಣಗಳನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ

ನೀವು ಈಗಾಗಲೇ ಅರ್ಥಮಾಡಿಕೊಂಡಂತೆ, ಪಟ್ಟಿಯ ಅಂಶಗಳ ಸಂಖ್ಯೆಯು ಸಹ ಶೂನ್ಯದಿಂದ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ, ಮತ್ತು ನಾವು ಚದರ ಆವರಣಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಅದರ ಸೂಚ್ಯಂಕದಿಂದ ಯಾವುದೇ ಅಂಶವನ್ನು ಪ್ರವೇಶಿಸಬಹುದು:

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

A = 0 ಗೆ ಪಟ್ಟಿಯಿಂದ.ಪ್ರಮಾಣ() - 1 ಲೂಪ್ ವರದಿ(ಪಟ್ಟಿ[A].ಮೌಲ್ಯ);

ಎಂಡ್ಸೈಕಲ್;

ಸ್ವತಃ ನಕಲನ್ನು ರಚಿಸಬಹುದು

ಮೌಲ್ಯಗಳ ಪಟ್ಟಿಯು ಕೇವಲ ಉತ್ತಮ ವೈಶಿಷ್ಟ್ಯವನ್ನು ಹೊಂದಿದೆ - ಅದು ಸ್ವತಃ ನಕಲನ್ನು ರಚಿಸಬಹುದು:

ListCopy = List.Copy();

// ಪಟ್ಟಿಯ ನಕಲನ್ನು ಮಾಡಿದೆ // ಈಗ ನಾವು ಪಟ್ಟಿಯ ನಕಲನ್ನು ಸುರಕ್ಷಿತವಾಗಿ ಬದಲಾಯಿಸಬಹುದು // ಆದರೆ ಮೂಲ ಪಟ್ಟಿಯು ಪಟ್ಟಿಯ ನಕಲನ್ನು ಬದಲಾಯಿಸುವುದಿಲ್ಲ. ಮೌಲ್ಯ = 123456;

ಅರೇ ಆಗಿ ಬದಲಾಗಬಹುದು

ಮತ್ತು ಅಂತಿಮವಾಗಿ, ನೀವು ಯಾವುದೇ ಸಮಯದಲ್ಲಿ ಪಟ್ಟಿಯ ಎಲ್ಲಾ ಅಂಶಗಳನ್ನು ಸುಲಭವಾಗಿ ಒಂದು ಶ್ರೇಣಿಗೆ ಡಂಪ್ ಮಾಡಬಹುದು:

ArrayNumbers = ಪಟ್ಟಿ. ಅನ್ಲೋಡ್ ಮೌಲ್ಯಗಳು();

// ರಚನೆಯೊಳಗೆ ಎಸೆಯಲಾಗಿದೆ

A = 0 ಗೆ ArrayNumber.Quantity() - 1 ಸೈಕಲ್

ವರದಿ(ArrayNumbers[A]); // // ಆಯ್ಕೆಯ ಮೌಲ್ಯವನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುವ ಅಗತ್ಯವಿಲ್ಲ

ಎಂಡ್ಸೈಕಲ್;

ಈ ಘಟಕದ ವಸ್ತುವನ್ನು ಅಭ್ಯಾಸ ಮಾಡಲು ಮತ್ತು ಕ್ರೋಢೀಕರಿಸಲು, ಈ ಕೆಳಗಿನ ಕಾರ್ಯವನ್ನು ಪೂರ್ಣಗೊಳಿಸಲು ಸೂಚಿಸಲಾಗುತ್ತದೆ.

ಬಳಕೆದಾರರಿಂದ 5 ಸಂಖ್ಯೆಗಳನ್ನು ನಮೂದಿಸುವುದು ಅವಶ್ಯಕವಾಗಿದೆ, ಅವುಗಳಲ್ಲಿ ದೊಡ್ಡ ಮತ್ತು ಚಿಕ್ಕದನ್ನು ಕಂಡುಹಿಡಿಯಿರಿ ಮತ್ತು ಅವುಗಳನ್ನು ಬಳಕೆದಾರರಿಗೆ ಪ್ರದರ್ಶಿಸಿ. ಪರಿಹಾರವು ಮೌಲ್ಯಗಳ ಪಟ್ಟಿಯನ್ನು ಬಳಸಬೇಕು.

ಪರಿಹಾರ

ಪಟ್ಟಿ = ಹೊಸ ಮೌಲ್ಯಪಟ್ಟಿ;

// A = 1 ಮೂಲಕ 5 ಸೈಕಲ್ ಸಂಖ್ಯೆ = 0 ಗಾಗಿ ಮೌಲ್ಯಗಳ ಪಟ್ಟಿಯನ್ನು ರಚಿಸಲಾಗಿದೆ;

EnterNumber(ಸಂಖ್ಯೆ); // ಬಳಕೆದಾರರ ಪಟ್ಟಿಯಿಂದ ಸಂಖ್ಯೆಯನ್ನು ನಮೂದಿಸಿ. ಸೇರಿಸಿ (ಸಂಖ್ಯೆ); // ಮತ್ತು ಪಟ್ಟಿಗೆ ಸೇರಿಸಿ ಎಂಡ್ಸೈಕಲ್; // ಮತ್ತು ಹೀಗೆ 5 ಬಾರಿ

// ಸಂಖ್ಯೆಗಳ ಪಟ್ಟಿಯನ್ನು ವಿಂಗಡಿಸಿ

ಪಟ್ಟಿ. ಮೌಲ್ಯದ ಪ್ರಕಾರ ವಿಂಗಡಿಸಿ (SortDirection.Age);

// ವಿಂಗಡಿಸಿದ ನಂತರ, ಪಟ್ಟಿಯ ಮೊದಲ ಅಂಶವು // ಚಿಕ್ಕ ಅಂಶವಾಗಿದೆ ಮತ್ತು ಕೊನೆಯದು ದೊಡ್ಡ OpenValue ("ಚಿಕ್ಕ ಅಂಶ" + ಪಟ್ಟಿ +

", ಮತ್ತು ಅತಿದೊಡ್ಡ " + ಪಟ್ಟಿ[List.Quantity() - 1]);