1c ಮೌಲ್ಯಗಳ ಕೋಷ್ಟಕದ ಸಂಪೂರ್ಣ ಕಾಲಮ್ ಅನ್ನು ಭರ್ತಿ ಮಾಡಿ. ವಸ್ತುವಿನ ಆಸ್ತಿ ಮತ್ತು ವಸ್ತು ವಿಧಾನವನ್ನು ಎಂದಿಗೂ ಗೊಂದಲಗೊಳಿಸದಿರುವುದು ಮುಖ್ಯವಾಗಿದೆ

ಆರಂಭಿಕರಿಗಾಗಿ ಸ್ವಲ್ಪ ಸಂಗತಿ ಇಲ್ಲಿದೆ - ಮೌಲ್ಯಗಳ ಕೋಷ್ಟಕದೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವ ಸರಳ ಉದಾಹರಣೆಗಳು:

1. ಮೌಲ್ಯಗಳ ಕೋಷ್ಟಕವನ್ನು ರಚಿಸಿ

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

2. ಮೌಲ್ಯಗಳ ಕೋಷ್ಟಕಕ್ಕಾಗಿ ಕಾಲಮ್‌ಗಳನ್ನು ರಚಿಸಿ:

ValueTable.Columns.Add("ಹೆಸರು");
ಮೌಲ್ಯ ಕೋಷ್ಟಕ.ಕಾಲಮ್‌ಗಳನ್ನು ಸೇರಿಸಿ("ಕೊನೆಯ ಹೆಸರು");

3. ಕಾಲಮ್ ಹೆಸರುಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಹೊಸ ಸಾಲುಗಳನ್ನು ಸೇರಿಸಿ:

NewLine.Name = "ವಾಸಿಲಿ";
NewLine.LastName = "ಪುಪ್ಕಿನ್";

4. ಮೌಲ್ಯ ಕೋಷ್ಟಕದಲ್ಲಿ ಮೌಲ್ಯವನ್ನು ಹೇಗೆ ನೋಡುವುದು:
ಅಪೇಕ್ಷಿತ ಮೌಲ್ಯವನ್ನು ಹೊಂದಿರುವ ಟೇಬಲ್ ಸಾಲನ್ನು ಕಂಡುಹಿಡಿಯುವುದು ಅವಶ್ಯಕ.

FoundRow = ValueTable.Find(SearchValue);

5. ಮೌಲ್ಯಗಳ ಕೋಷ್ಟಕದ ಕೆಲವು ಕಾಲಮ್‌ಗಳಲ್ಲಿ ಮೊದಲ ಸಂಭವವನ್ನು ಕಂಡುಹಿಡಿಯಿರಿ

FoundRow = ValueTable.Find(SearchValue, "Supplier, Buyer");

6. ಮೌಲ್ಯಗಳ ಕೋಷ್ಟಕದಲ್ಲಿ ನೀವು ಎಲ್ಲಾ ಘಟನೆಗಳನ್ನು ಕಂಡುಹಿಡಿಯಬೇಕಾದರೆ:
ನಾವು ಹುಡುಕಾಟ ರಚನೆಯನ್ನು ಬಳಸುತ್ತೇವೆ.

SearchStructure = ರಚನೆ("ಉದ್ಯೋಗಿ", SearchValue);
FoundRows ನ ಅರೇ = ValueTable.FindRows(SearchStructure);

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

7. ಯಾದೃಚ್ಛಿಕ ಕ್ರಮದಲ್ಲಿ ಮೌಲ್ಯಗಳ ಕೋಷ್ಟಕದ ಮೂಲಕ ಪುನರಾವರ್ತಿಸುವುದು ಹೇಗೆ

ಮೌಲ್ಯಗಳ ಕೋಷ್ಟಕದಿಂದ ಪ್ರತಿ ಪ್ರಸ್ತುತ ಸಾಲಿಗೆ ಲೂಪ್
ವರದಿ(CurrentRow.Name);
ಎಂಡ್ಸೈಕಲ್;

ಸೂಚ್ಯಂಕಗಳನ್ನು ಬಳಸುವ ಒಂದೇ ವಿಷಯ:

ಸೀನಿಯರ್ಇಂಡೆಕ್ಸ್ = ಮೌಲ್ಯಪಟ್ಟಿ.ಪ್ರಮಾಣ() - 1;
ಖಾತೆಗೆ = 0 ಗೆ ಸೀನಿಯರ್ ಇಂಡೆಕ್ಸ್ ಸೈಕಲ್
ವರದಿ(ಕೋಷ್ಟಕ ಮೌಲ್ಯಗಳು[ಖಾತೆ].ಹೆಸರು);
ಎಂಡ್ಸೈಕಲ್;

8. ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಮೌಲ್ಯದ ಟೇಬಲ್ ಸಾಲನ್ನು ಅಳಿಸಲಾಗುತ್ತಿದೆ

ValueTable.Delete(ಸಾಲು ಅಳಿಸಬೇಕು);

ಸೂಚ್ಯಂಕದಿಂದ

ValueTable.Delete(0);

9. ಮೌಲ್ಯದ ಕೋಷ್ಟಕದ ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಕಾಲಮ್ ಅನ್ನು ಅಳಿಸಲಾಗುತ್ತಿದೆ

ValueTable.Columns.Delete(ಕಾಲಮ್ ಅಳಿಸಲಾಗಿದೆ);

ಸೂಚ್ಯಂಕದಿಂದ

ValueTable.Columns.Delete(0);

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

10. ಕಾಲಮ್ ಹೆಸರುಗಳು ಅಸ್ಥಿರಗಳಲ್ಲಿದ್ದರೆ ಮೌಲ್ಯಗಳ ಕೋಷ್ಟಕವನ್ನು ಹೇಗೆ ತುಂಬುವುದು?

NewRow = ValueTable.Add();
NewRow[ColumnName] = ಮೌಲ್ಯ;

11. ಮೌಲ್ಯದ ಕೋಷ್ಟಕದ ಸಂಪೂರ್ಣ ಕಾಲಮ್ ಅನ್ನು ಅಪೇಕ್ಷಿತ ಮೌಲ್ಯದೊಂದಿಗೆ ಹೇಗೆ ತುಂಬುವುದು?
ಮೌಲ್ಯಗಳ ಕೋಷ್ಟಕದಲ್ಲಿನ ಹಣಕಾಸಿನ ಲೆಕ್ಕಪತ್ರದ ಫ್ಲ್ಯಾಗ್ ಕಾಲಮ್ ಅನ್ನು ಮೌಲ್ಯದ ತಪ್ಪಿನಿಂದ ತುಂಬಬೇಕು

ಮೌಲ್ಯಗಳ ಕೋಷ್ಟಕ. ಮೌಲ್ಯಗಳನ್ನು ಭರ್ತಿ ಮಾಡಿ (ಸುಳ್ಳು, "ಹಣ ಲೆಕ್ಕಪತ್ರ ಧ್ವಜ");

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

12. ಮೌಲ್ಯ ಕೋಷ್ಟಕ "ಮೂಲಪಟ್ಟಿ" ಯಿಂದ ಡೇಟಾದೊಂದಿಗೆ ನಾನು ಮೌಲ್ಯ ಕೋಷ್ಟಕ "ರಿಸೀವರ್ ಟೇಬಲ್" ಅನ್ನು ಹೇಗೆ ತುಂಬಬಹುದು?

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

ಸ್ವೀಕರಿಸುವವರ ಕೋಷ್ಟಕ = ಮೂಲ ಕೋಷ್ಟಕ.ನಕಲು();

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

ಹೊಂದಾಣಿಕೆಯ ಹೆಸರುಗಳೊಂದಿಗೆ ಕಾಲಮ್‌ಗಳಿಗೆ ಭಾಗಶಃ ಡೇಟಾ ವರ್ಗಾವಣೆ:

ಸೋರ್ಸ್ಟೇಬಲ್ ಸೈಕಲ್‌ನಿಂದ ಸೋರ್ಸ್‌ಟೇಬಲ್‌ನ ಪ್ರತಿ ಸಾಲಿಗೆ
FillPropertyValues (NewRow, SourceTableRow);
ಸೈಕಲ್ ಅಂತ್ಯ

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

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

ಹೊಂದಾಣಿಕೆಯ ಹೆಸರುಗಳೊಂದಿಗೆ ಕಾಲಮ್‌ಗಳಿಗಾಗಿ ಡೇಟಾದ ಪೂರ್ಣ ನಕಲು

ಅದೇ ಕಾಲಮ್‌ಗಳು = ಹೊಸ ಅರೇ();

SourceTable.Columns ಸೈಕಲ್‌ನಿಂದ ಪ್ರತಿ ಕಾಲಮ್‌ಗೆ
MatchingColumn = TableReceiver.Columns.Find(Column.Name);

ಕಾಲಮ್ ಹೊಂದಾಣಿಕೆಯಾಗಿದ್ದರೆ<>ನಂತರ ವಿವರಿಸಲಾಗಿಲ್ಲ

// ಕಾಲಮ್ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಪಡೆಯಿರಿ.
ಹೆಸರು = ಕಾಲಮ್.ಹೆಸರು;
ಮೌಲ್ಯ ಪ್ರಕಾರ = ಕಾಲಮ್.ಮೌಲ್ಯಮಾದರಿ;
ಹೆಡರ್ = ಕಾಲಮ್.ಹೆಡರ್;
ಅಗಲ = ಅಂಕಣ.ಅಗಲ;

// ಗಮ್ಯಸ್ಥಾನ ಕೋಷ್ಟಕದಲ್ಲಿ ಕಾಲಮ್‌ಗಳನ್ನು ಬದಲಾಯಿಸಿ.
ಸೂಚ್ಯಂಕ = TableReceiver.Columns.Index(MatchingColumn);

TableReceiver.Columns.Delete(ಸೂಚ್ಯಂಕ);
ಸ್ವೀಕರಿಸುವವರ ಕೋಷ್ಟಕ.ಕಾಲಮ್‌ಗಳು. ಸೇರಿಸಿ (ಸೂಚ್ಯಂಕ, ಹೆಸರು, ಮೌಲ್ಯ ಪ್ರಕಾರ, ಶಿರೋಲೇಖ, ಅಗಲ);

// ಹೊಂದಾಣಿಕೆಯ ಕಾಲಮ್‌ಗಳ ಮುಂದಿನ ಹೆಸರನ್ನು ಶ್ರೇಣಿಗೆ ಸೇರಿಸಿ.
ಅದೇ ಅಂಕಣಗಳು.ಸೇರಿಸು(Column.Name);

ಕೊನೆಯಲ್ಲಿ ವೇಳೆ;

ಎಂಡ್ಸೈಕಲ್;

// ಮೂಲ ಕೋಷ್ಟಕದ ಸಾಲುಗಳ ಮೂಲಕ ಸೈಕಲ್ ಮಾಡಿ.
ಸೋರ್ಸ್ಟೇಬಲ್ ಚಕ್ರದಿಂದ ಸೋರ್ಸ್ಟೇಬಲ್ನ ಪ್ರತಿ ಸಾಲಿಗೆ

// ಸೇರಿಸಿ ಹೊಸ ಗೆರೆಸ್ವೀಕರಿಸುವ ಟೇಬಲ್‌ಗೆ.
NewRow = TableReceiver.Add();

// ಹೊಂದಾಣಿಕೆಯ ಕೋಶಗಳಲ್ಲಿ ಮೌಲ್ಯಗಳನ್ನು ಭರ್ತಿ ಮಾಡಿ.
ಪ್ರತಿ ಹೆಸರಿನ ಕಾಲಮ್‌ಗಳಿಗೆ ಅದೇ ಹೆಸರಿನ ಕಾಲಮ್‌ಗಳಿಂದ ಸೈಕಲ್
NewRow[ColumnName] = SourceTableRow[ColumnName];

ಎಂಡ್ಸೈಕಲ್;

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

13. ವಿಧದ ನಿರ್ಬಂಧಗಳೊಂದಿಗೆ ಮೌಲ್ಯಗಳ "ಮೌಲ್ಯಪಟ್ಟಿ" ಕೋಷ್ಟಕಕ್ಕೆ ಕಾಲಮ್ಗಳನ್ನು ಹೇಗೆ ಸೇರಿಸುವುದು?

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

ಡೇಟಾ ಪ್ರಕಾರವನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸದೆ ಕಾಲಮ್ ಅನ್ನು ಸೇರಿಸಲಾಗುತ್ತಿದೆ

// ಪ್ರಕಾರದ ಮೇಲೆ ನಿರ್ಬಂಧಗಳಿಲ್ಲದೆ ಕಾಲಮ್ ಸೇರಿಸಿ.
ValueTable.Columns.Add("ಆಬ್ಜೆಕ್ಟ್");

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

ಡೇಟಾ ಪ್ರಕಾರವನ್ನು ಸೂಚಿಸುವ ಕಾಲಮ್ ಅನ್ನು ಸೇರಿಸಲಾಗುತ್ತಿದೆ

// ಕಾಲಮ್ ಡೇಟಾ ಪ್ರಕಾರಗಳ ಮೇಲಿನ ನಿರ್ಬಂಧಗಳು:
// "ಕೌಂಟರ್‌ಪಾರ್ಟೀಸ್" ಡೈರೆಕ್ಟರಿಯ ಅಂಶಗಳು ಮಾತ್ರ.
ಮೌಲ್ಯಗಳ ಕೋಷ್ಟಕ.ಕಾಲಮ್‌ಗಳು.ಸೇರಿಸು("ಖಾತೆ", ಪ್ರಕಾರಗಳ ಹೊಸ ವಿವರಣೆ("ಡೈರೆಕ್ಟರಿಲಿಂಕ್.ಖಾತೆಗಳು"));

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

ಮೌಲ್ಯದ ಟೇಬಲ್ ಕಾಲಮ್‌ನ ಡೇಟಾ ಪ್ರಕಾರವನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಲು ಅರ್ಹತೆಗಳನ್ನು ಬಳಸುವುದು

// ಸ್ಟ್ರಿಂಗ್ ಪ್ರಕಾರದ ಡೇಟಾಕ್ಕಾಗಿ ತಯಾರಿ ಮತ್ತು ನಿರ್ಬಂಧಗಳನ್ನು ಹೊಂದಿಸಿ.
ಸ್ಟ್ರಿಂಗ್ ಕ್ವಾಲಿಫೈಯರ್‌ಗಳು = ಹೊಸ ಸ್ಟ್ರಿಂಗ್ ಕ್ವಾಲಿಫೈಯರ್‌ಗಳು(20, ಅನುಮತಿಸಿದ ಉದ್ದ.ವೇರಿಯಬಲ್);
ವ್ಯಾಲಿಡ್ ಟೈಪ್ಸ್ = ನ್ಯೂಟೈಪ್ ಡಿಸ್ಕ್ರಿಪ್ಶನ್("ಸ್ಟ್ರಿಂಗ್", ಸ್ಟ್ರಿಂಗ್ ಕ್ವಾಲಿಫೈಯರ್ಸ್);
ValueTable.Columns.Add("NoteStringShort", ValidTypes);

ಸಂಖ್ಯೆ ಮತ್ತು ದಿನಾಂಕದ ಅರ್ಹತೆಗಳಿಗೆ ಸಂಬಂಧಿಸಿದಂತೆ ಇದೇ ರೀತಿಯ ಕ್ರಿಯೆಗಳನ್ನು ಮಾಡಬಹುದು.
ದಯವಿಟ್ಟು ಗಮನಿಸಿ: ಪ್ರಕಾರದ ವಿವರಣೆಗಳನ್ನು ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್‌ನಿಂದ "ಮೊದಲಿನಿಂದ" ನಿರ್ಮಿಸಬಹುದು ಅಥವಾ ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಪ್ರಕಾರದ ವಿವರಣೆಯನ್ನು ಆಧಾರವಾಗಿ ಬಳಸಬಹುದು.

ಮೌಲ್ಯದ ಟೇಬಲ್ ಕಾಲಮ್‌ನ ಡೇಟಾ ಪ್ರಕಾರವನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಲು ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಪ್ರಕಾರದ ಘೋಷಣೆಗಳನ್ನು ಬಳಸುವುದು

// ಹಿಂದೆ ಬಳಸಿದ ಪ್ರಕಾರದ ವಿವರಣೆಯ ವಿಸ್ತರಣೆ.
ಅರ್ಹತಾ ಸಂಖ್ಯೆಗಳು = ಹೊಸ ಅರ್ಹತಾ ಸಂಖ್ಯೆಗಳು(10, 2, ಮಾನ್ಯ ಚಿಹ್ನೆ. ಋಣಾತ್ಮಕವಲ್ಲದ);
ದಿನಾಂಕ ಕ್ವಾಲಿಫೈಯರ್‌ಗಳು = ಹೊಸ ದಿನಾಂಕ ಕ್ವಾಲಿಫೈಯರ್‌ಗಳು (ಡೇಟ್‌ಪಾರ್ಟ್ಸ್. ದಿನಾಂಕ);
ವಿಸ್ತೃತ ಮಾನ್ಯ ವಿಧಗಳು = ಹೊಸ ವಿಧದ ವಿವರಣೆ (ಮಾನ್ಯ ಪ್ರಕಾರಗಳು, "ಸಂಖ್ಯೆ, ದಿನಾಂಕ", ಸಂಖ್ಯೆ ಅರ್ಹತೆಗಳು, ದಿನಾಂಕ ಅರ್ಹತೆಗಳು);

ValueTable.Columns.Add("ಟಿಪ್ಪಣಿ", ವಿಸ್ತೃತ ಸ್ವೀಕಾರಾರ್ಹ ಪ್ರಕಾರಗಳು);

infostart ನ ಎಲ್ಲಾ ಓದುಗರಿಗೆ ಶುಭಾಶಯಗಳು. ಈ ಲೇಖನವು ನಿರ್ವಹಿಸಿದ ಅಪ್ಲಿಕೇಶನ್‌ನ ರೂಪದಲ್ಲಿ ಮೌಲ್ಯಗಳ ಕಸ್ಟಮ್ ಕೋಷ್ಟಕವನ್ನು ರಚಿಸುವ ವಿಷಯದ ಮೇಲೆ ಕೇಂದ್ರೀಕರಿಸುತ್ತದೆ ಪ್ರೋಗ್ರಾಮಿಕ್ ಆಗಿ.

ಕಾರ್ಯದ ವೈಶಿಷ್ಟ್ಯಗಳು.

ಪ್ರೋಗ್ರಾಮ್ ಮಾಡಿದ ಯಾರಾದರೂ ನಿಯಮಿತ ಅಪ್ಲಿಕೇಶನ್, ಫಾರ್ಮ್‌ನಲ್ಲಿ ಮೌಲ್ಯಗಳ ಅನಿಯಂತ್ರಿತ ಕೋಷ್ಟಕವನ್ನು ಪಡೆಯುವ ಕಾರ್ಯವನ್ನು ನಾನು ಆಗಾಗ್ಗೆ ಎದುರಿಸುತ್ತಿದ್ದೆ. ಮೌಲ್ಯಗಳ ಅನಿಯಂತ್ರಿತ ಕೋಷ್ಟಕವು ಒಂದು ಕೋಷ್ಟಕವಾಗಿದ್ದು, ಅದರ ಸಂಖ್ಯೆ ಮತ್ತು ಕಾಲಮ್‌ಗಳ ಪ್ರಕಾರವು ಮುಂಚಿತವಾಗಿ ತಿಳಿದಿಲ್ಲ. ಅಂದರೆ, 3 ಕಾಲಮ್‌ಗಳು, ಅಥವಾ ಬಹುಶಃ 6, ಅಥವಾ 8 ಇರಬಹುದು. ಸಾಮಾನ್ಯ ಅಪ್ಲಿಕೇಶನ್‌ನಲ್ಲಿ, ಎಲ್ಲವೂ ಸರಳವಾಗಿದೆ: ನೀವು "ಮೌಲ್ಯಗಳ ಕೋಷ್ಟಕ" ಅಂಶವನ್ನು ಸಂಸ್ಕರಣಾ ಫಾರ್ಮ್‌ನಲ್ಲಿ ಇರಿಸಬಹುದು ಮತ್ತು ನಂತರ ರಚಿಸಿದ ಮೌಲ್ಯಗಳ ಕೋಷ್ಟಕವನ್ನು ವರ್ಗಾಯಿಸಬಹುದು ಪ್ರೋಗ್ರಾಮಿಕ್ ಆಗಿ ಈ ಅಂಶಕ್ಕೆ. ನಂತರ ಸರಳ ಆಜ್ಞೆಯೊಂದಿಗೆ:

Form Elements.TableField.CreateColumns();

ಫಾರ್ಮ್‌ನಲ್ಲಿ ಮೌಲ್ಯಗಳ ಸಿದ್ಧ ಕೋಷ್ಟಕವನ್ನು ಪಡೆಯಿರಿ. ಇದು ಸರಳವಾಗಿರಬಹುದು ಎಂದು ತೋರುತ್ತದೆ.

ಇದೆಲ್ಲವೂ ಸಾಮಾನ್ಯ ಅಪ್ಲಿಕೇಶನ್‌ನಲ್ಲಿತ್ತು. ನಿರ್ವಹಿಸಲಾದ ಅಪ್ಲಿಕೇಶನ್‌ನಲ್ಲಿ, ಎಲ್ಲವೂ ಬದಲಾಗಿದೆ. ಅನಿಯಂತ್ರಿತ ಕೋಷ್ಟಕವನ್ನು ರಚಿಸುವುದು ಅಷ್ಟು ಸುಲಭವಲ್ಲ. ಈಗ ನೀವು ಫಾರ್ಮ್‌ನಲ್ಲಿನ ಮೌಲ್ಯಗಳ ಕೋಷ್ಟಕವನ್ನು ಕಟ್ಟುನಿಟ್ಟಾಗಿ ಪ್ಯಾರಾಮೀಟರ್ ಮಾಡಬೇಕಾಗಿದೆ, ಅಥವಾ ಅದನ್ನು ಪ್ರೋಗ್ರಾಮಿಕ್ ಆಗಿ ರಚಿಸಿ (ವಿವರಿಸಿ, ಅಲ್ಲದೆ, ಇದು ವಾಸ್ತವವಾಗಿ, ನಿರ್ವಹಿಸಿದ ಅಪ್ಲಿಕೇಶನ್‌ನ ಸಾರವಾಗಿದೆ). ನಾವು ಇದನ್ನು ಮಾಡಲು ಪ್ರಯತ್ನಿಸುತ್ತೇವೆ: ಸಾಫ್ಟ್ವೇರ್ಮೌಲ್ಯಗಳ ಕಸ್ಟಮ್ ಕೋಷ್ಟಕವನ್ನು ರಚಿಸಿ ನಿರ್ವಹಿಸಬಹುದಾದ ರೂಪದಲ್ಲಿ.

ಸಮಸ್ಯೆಯ ಪರಿಹಾರ.

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

ಫಾರ್ಮ್‌ನಲ್ಲಿ ಟೇಬಲ್‌ನ ರಚನೆಯು ಮೌಲ್ಯ ಕೋಷ್ಟಕವನ್ನು ಗುಣಲಕ್ಷಣವಾಗಿ ವಿವರಿಸುವ ಮೂಲಕ ಸಂಭವಿಸುತ್ತದೆ:
SelectionTypeArray = ಹೊಸ ಅರೇ; SelectionType.Add (ಪ್ರಕಾರ("ಮೌಲ್ಯ ಕೋಷ್ಟಕ")); ChoiceTypeDescription = ಹೊಸ TypeDescription(ChoiceTypeArray); ವಿವರಗಳ ಅರೇ = ಹೊಸ ಅರೇ; ಗುಣಲಕ್ಷಣಗಳ ಅರೇ. ಸೇರಿಸಿ(ಹೊಸ ಫಾರ್ಮ್ ಗುಣಲಕ್ಷಣಗಳು("ವೇಳಾಪಟ್ಟಿ ಕೋಷ್ಟಕ", ಆಯ್ಕೆ ಪ್ರಕಾರದ ವಿವರಣೆ, "", "TZN")); ಈಗ ನಾವು ಡೇಟಾವನ್ನು ಒಳಗೊಂಡಿರುವ ಪ್ರೋಗ್ರಾಂ ಮೌಲ್ಯ ಕೋಷ್ಟಕವನ್ನು ರಚಿಸಬೇಕಾಗಿದೆ. ಮೌಲ್ಯಗಳ ಕೋಷ್ಟಕವನ್ನು ಪ್ರಶ್ನೆಯಿಂದ ಪಡೆದರೆ, ಎಲ್ಲವೂ ಹೆಚ್ಚು ಅಥವಾ ಕಡಿಮೆ ಕ್ರಮದಲ್ಲಿರುತ್ತವೆ. ಟೇಬಲ್ ಅನ್ನು ಹಸ್ತಚಾಲಿತವಾಗಿ ರಚಿಸಿದರೆ, ಸಂಖ್ಯೆಗಳು ಅಥವಾ ದಿನಾಂಕಗಳನ್ನು ಒಳಗೊಂಡಿರುವ ಕಾಲಮ್‌ಗಳ ಅರ್ಥವನ್ನು "ಪ್ರಕಾರಗಳ ವಿವರಣೆ" ಮೂಲಕ ರಚಿಸಬಹುದು. ಮೌಲ್ಯಗಳ ಕೋಷ್ಟಕದಲ್ಲಿನ ಕಾಲಮ್‌ಗಳು ಕೆಲವು ಪ್ರಕಾರಗಳನ್ನು ಹೊಂದಿರಬೇಕು ಎಂಬುದು ಪಾಯಿಂಟ್. ಉದಾಹರಣೆಗೆ, ಬಳಕೆದಾರರು ಈ ಕಾಲಮ್‌ಗಳಲ್ಲಿ ಡೇಟಾವನ್ನು ಸಂವಾದಾತ್ಮಕವಾಗಿ ತುಂಬುತ್ತಾರೆ ಎಂದು ನಿರೀಕ್ಷಿಸಿದರೆ, ನಂತರ ನೀವು ಮೌಲ್ಯ ಕೋಷ್ಟಕದ ಕಾಲಮ್ ಅನ್ನು ಹೆಸರಿನೊಂದಿಗೆ ಸರಳವಾಗಿ ಸೇರಿಸಲಾಗುವುದಿಲ್ಲ; ಅದು ಒಂದು ಪ್ರಕಾರವನ್ನು ಹೊಂದಿರಬೇಕು. ನೆನಪಿನಲ್ಲಿಡಿ - ಇದು ಬಹಳ ಮುಖ್ಯ ಏಕೆಂದರೆ ... ನಾವು ಈ ಪ್ರಕಾರಗಳನ್ನು ಫಾರ್ಮ್‌ನಲ್ಲಿ ಟೇಬಲ್‌ಗೆ ವರ್ಗಾಯಿಸುತ್ತೇವೆ.
ನಾವು ಹಲವಾರು ಕಾಲಮ್‌ಗಳನ್ನು ಒಳಗೊಂಡಿರುವ ಟೇಬಲ್ ಅನ್ನು ರಚಿಸುತ್ತೇವೆ:
CD = NewDate Qualifiers(DateParts.Time); ArrayKD = ಹೊಸ ಅರೇ; ArrayCD.Add(ಪ್ರಕಾರ("ದಿನಾಂಕ")); ವಿವರಣೆ ಪ್ರಕಾರದ ಸಮಯ = ಹೊಸ ವಿವರಣೆ ಪ್ರಕಾರಗಳು(ArrayCD,CD); TZ = ಹೊಸ ಮೌಲ್ಯಪಟ್ಟಿ;
TK.Columns.Add("with", DescriptionTypesTime);
TK.Columns.Add("ಮೊದಲು", ವಿವರಣೆ ಟೈಪ್ಸ್ಟೈಮ್);
TK.Columns.Add("ಹೆಸರು");
TK.Columns.Add("ಟಿಪ್ಪಣಿ"); // ಪೂರ್ಣ ಹೆಸರು ಮತ್ತು ಟಿಪ್ಪಣಿ - ಸಾಲುಗಳು ಮುಂದೆ, ನಾವು ನಮ್ಮ TK ಪ್ರೋಗ್ರಾಂ ಟೇಬಲ್ ಅನ್ನು ಅಗತ್ಯ ಡೇಟಾದೊಂದಿಗೆ ತುಂಬುತ್ತೇವೆ. ನಾವು ಅಗತ್ಯವಾದ ಮೌಲ್ಯಗಳನ್ನು ಒಳಗೊಂಡಿರುವ TK ಟೇಬಲ್ ಅನ್ನು ಸ್ವೀಕರಿಸುತ್ತೇವೆ ಮತ್ತು ರಚಿಸಿದ ಫಾರ್ಮ್ ಗುಣಲಕ್ಷಣಕ್ಕೆ ವರ್ಗಾಯಿಸಲು ಸಿದ್ಧವಾಗಿದೆ. TK. ಕಾಲಮ್‌ಗಳ ಸೈಕಲ್‌ನಿಂದ ಪ್ರತಿ ಕಾಲಮ್‌ಗೆ

ಗುಣಲಕ್ಷಣಗಳ ಅರೇ. ಸೇರಿಸಿ (ಹೊಸ ಫಾರ್ಮ್ ಗುಣಲಕ್ಷಣಗಳು(ಕಾಲಮ್.ಹೆಸರು, ಕಾಲಮ್.ಮೌಲ್ಯಮಾದರಿ,"ವೇಳಾಪಟ್ಟಿ"));

ಎಂಡ್ಸೈಕಲ್;
ಬದಲಾವಣೆ ವಿವರಗಳು (ಅರೇ ವಿವರಗಳು);
SelectionFieldsTable = Elements.Add("TZN", Type("FormTable"));
SelectionFieldsTable.DataPath = "ScheduleTable";
SelectionFieldTable.Display = TableDisplay.List;

ಇದು ಸರಳ ಸಂಯೋಜನೆಯಾಗಿದೆ ಮತ್ತು ನಮ್ಮ ಟೇಬಲ್ ಸಿದ್ಧವಾಗಿದೆ.

TK. ಕಾಲಮ್‌ಗಳ ಸೈಕಲ್‌ನಿಂದ ಪ್ರತಿ ಕಾಲಮ್‌ಗೆ

NewElement = Elements.Add(Column.Name, Type("FormField"), SelectionFieldTable);
NewElement.View = FormFieldView.InputField;
NewElement.DataPath = "ScheduleTable." + ಕಾಲಮ್.ಹೆಸರು;
NewElement.Width = 10;

ಎಂಡ್ಸೈಕಲ್;

ಷರತ್ತುಬದ್ಧ ವಿನ್ಯಾಸ, ನಮಗೆ ಅಗತ್ಯವಿದ್ದರೆ, ನಾವು ಅದನ್ನು ಕೈಯಾರೆ ಬರೆಯುತ್ತೇವೆ, ಕಮಾಂಡ್ ಮೆನು - ಹಸ್ತಚಾಲಿತವಾಗಿ. ಟೇಬಲ್ ಹ್ಯಾಂಡ್ಲರ್‌ಗಳನ್ನು ಸಹ ಕೈಯಿಂದ ಬರೆಯಲಾಗುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, "ಆಯ್ಕೆ" ಕೋಷ್ಟಕಕ್ಕೆ ಈವೆಂಟ್ ಹ್ಯಾಂಡ್ಲರ್ ಅನ್ನು ಸೇರಿಸಲು:

SelectionFields.SetAction("ಆಯ್ಕೆ","TZNSelection");

ಈ ಘಟನೆಯನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು, ಕಾರ್ಯವಿಧಾನದ ರೂಪದಲ್ಲಿ ಪ್ರತ್ಯೇಕ ವಿಧಾನವನ್ನು ಸೂಚಿಸಲಾಗುತ್ತದೆ:

&ಆನ್ ಕ್ಲೈಂಟ್
ವಿಧಾನ TKNS ಆಯ್ಕೆ(TK, ಆಯ್ದ ಸಾಲು, ಕ್ಷೇತ್ರ, ಪ್ರಮಾಣಿತ ಪ್ರಕ್ರಿಯೆ)
// ಹ್ಯಾಂಡ್ಲರ್ ಆದೇಶಗಳು ಎಂಡ್ ಪ್ರೊಸೆಜರ್

ಟೇಬಲ್ ಹ್ಯಾಂಡ್ಲರ್‌ಗಳು ಕ್ಲೈಂಟ್‌ನಲ್ಲಿ ಗುಂಡು ಹಾರಿಸುತ್ತಾರೆ ಮತ್ತು ಆದ್ದರಿಂದ ಕಂಪೈಲರ್ ಪಾಯಿಂಟರ್ ಆಜ್ಞೆಯನ್ನು ಹೊಂದಿರಬೇಕು ಎಂಬುದನ್ನು ಗಮನಿಸಿ

&ಆನ್ ಕ್ಲೈಂಟ್

ಸರಿ, ನಾನು ಸೇರಿಸಲು ಬಯಸಿದ ಕೊನೆಯ ವಿಷಯವೆಂದರೆ ಈ ಎಲ್ಲಾ ಹಂತಗಳ ನಂತರ, ಸಿದ್ಧಪಡಿಸಿದ ಟೇಬಲ್ ಅನ್ನು ಫಾರ್ಮ್ ಗುಣಲಕ್ಷಣಕ್ಕೆ ರವಾನಿಸಲು ಮರೆಯದಿರಿ:

ಮೌಲ್ಯ ಫಾರ್ಮ್ ಗುಣಲಕ್ಷಣಗಳು(ToR, "ಶೆಡ್ಯೂಲ್ಟೇಬಲ್");

ಇದರ ಪರಿಣಾಮವಾಗಿ ನಾವು ಹೊಂದಿದ್ದೇವೆ:

ಮತ್ತು "ಆಯ್ಕೆ" ಈವೆಂಟ್‌ನ ನಿರ್ವಹಣೆ ಇಲ್ಲಿದೆ:

ನಂತರದ ಮಾತು.

ಪ್ರೋಗ್ರಾಮ್ಯಾಟಿಕ್ ಆಗಿ ಫಾರ್ಮ್‌ನಲ್ಲಿ ಕೋಷ್ಟಕಗಳನ್ನು ರಚಿಸಲು ಪ್ರಾರಂಭಿಸುವ 1C ಪ್ರೋಗ್ರಾಮರ್‌ಗಳಿಗೆ ಲೇಖನವು ಸಹಾಯ ಮಾಡುತ್ತದೆ ಎಂದು ನಾನು ಭಾವಿಸುತ್ತೇನೆ.

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

ಸೆಪ್ಟೆಂಬರ್ 21, 2011 ರಂದು ಪ್ರಕಟಿಸಲಾಗಿದೆ

ಮೌಲ್ಯಗಳ ಕೋಷ್ಟಕ 1C - ಭಾಗ 3. ಮೆಟಾಡೇಟಾ. ಮೌಲ್ಯದ ಟೇಬಲ್ ಕಾಲಮ್‌ಗಳ ಮೂಲಕ ಲೂಪ್ ಮಾಡಲಾಗುತ್ತಿದೆ

ಈ ಲೇಖನದಲ್ಲಿ "ಅಜ್ಞಾತ" ರಚನೆಯ ಮೌಲ್ಯಗಳ ಕೋಷ್ಟಕದೊಂದಿಗೆ ಹೇಗೆ ಕೆಲಸ ಮಾಡುವುದು, ಮೌಲ್ಯಗಳ ಕೋಷ್ಟಕದ ಕಾಲಮ್‌ಗಳ ಮೂಲಕ ಪುನರಾವರ್ತಿಸುವುದು ಹೇಗೆ, ಕಾಲಮ್ ಹೆಸರುಗಳನ್ನು ಬಳಸದೆ ಕಾಲಮ್‌ಗಳು ಮತ್ತು ಸಾಲುಗಳಿಂದ ಡೇಟಾವನ್ನು ಹೊರತೆಗೆಯುವುದು ಹೇಗೆ ಎಂದು ನಾನು ನಿಮಗೆ ಹೇಳುತ್ತೇನೆ. (ಈ ಲೇಖನವು ಮೊದಲಿನಿಂದ 1C ಲೇಖನಗಳ ಸರಣಿಗೆ ಸೇರಿದೆ; ಮೊದಲಿನಿಂದ 1C ಪ್ರೋಗ್ರಾಮಿಂಗ್; 1C ಮೌಲ್ಯಗಳ ಕೋಷ್ಟಕ)

ವಸ್ತುವನ್ನು ವಿವರಿಸಲು ಮತ್ತು ನಮ್ಮ ಕೋಡ್ ಉದಾಹರಣೆಗಳನ್ನು "ಲೈವ್" ರನ್ ಮಾಡಲು, ನಮಗೆ ಕೆಲವು ಅಗತ್ಯವಿದೆ ಮೌಲ್ಯಗಳ ಪರೀಕ್ಷಾ ಕೋಷ್ಟಕ 1C. ನಮ್ಮ ಕೆಲವು ಉದಾಹರಣೆಗಳು ಮೌಲ್ಯಗಳ ಕೋಷ್ಟಕದಿಂದ ಡೇಟಾವನ್ನು ಹೊರತೆಗೆಯುತ್ತವೆ, ಆದ್ದರಿಂದ ನಾವು "ಕೊನೆಯ ಹೆಸರು", "ಮೊದಲ ಹೆಸರು", "ಮಧ್ಯದ ಹೆಸರು" ಎಂಬ ಮೂರು ಕಾಲಮ್‌ಗಳೊಂದಿಗೆ ಟೇಬಲ್ ಅನ್ನು ಮಾಡುತ್ತೇವೆ ಮತ್ತು ಅದರಲ್ಲಿ ಸಣ್ಣ ಪ್ರಮಾಣದ ಡೇಟಾವನ್ನು ನಮೂದಿಸಿ - 3 ರಂತೆ ಸಾಲುಗಳು :)

ಆದ್ದರಿಂದ, ನಾವು 1C ಮೌಲ್ಯಗಳ ಪರೀಕ್ಷಾ ಕೋಷ್ಟಕವನ್ನು ರಚಿಸೋಣ ಮತ್ತು ಅದನ್ನು ಭರ್ತಿ ಮಾಡೋಣ:

MyTZ = ಹೊಸ ಮೌಲ್ಯಪಟ್ಟಿ; // ರಚಿಸಿ ಹೊಸ ಟೇಬಲ್ವೇರಿಯೇಬಲ್ "MyTZ" MyTZ.Columns.Add ("ಕೊನೆಯ ಹೆಸರು") ನಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾದ ಮೌಲ್ಯಗಳು; // "ಕೊನೆಯ ಹೆಸರು" ಕಾಲಮ್ ಅನ್ನು ರಚಿಸಿ MyTK.Columns.Add("ಹೆಸರು"); // ಕಾಲಮ್ ಅನ್ನು ರಚಿಸಿ "ಹೆಸರು" MyTZ.Columns.Add("Patronymic"); // "ಮಧ್ಯದ ಹೆಸರು" ಕಾಲಮ್ ಅನ್ನು ರಚಿಸಿ // ನಮ್ಮ ಮೌಲ್ಯಗಳ ಕೋಷ್ಟಕಕ್ಕೆ ಮೊದಲ ಸಾಲನ್ನು ಸೇರಿಸಿ NewLine = MyTZ.Add(); NewString.LastName = "ಚಾಪೇವ್"; NewLine.Name = "ವಾಸಿಲಿ"; NewString.Middle name = "Ivanovich"; // ಎರಡನೇ ಸಾಲನ್ನು ಸೇರಿಸಿ NewLine = MyTZ.Add(); NewString.LastName = "Dzerzhinsky"; NewRow.Name = "ಫೆಲಿಕ್ಸ್"; NewString.Middle name = "Edmundovich"; // ಮೂರನೇ ಸಾಲನ್ನು ಸೇರಿಸಿ NewLine = MyTZ.Add(); NewLine.LastName = "ಕೊಟೊವ್ಸ್ಕಿ"; NewLine.Name = "ಗ್ರೆಗೊರಿ"; NewString.Middle name = "Ivanovich";

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

ಮೊದಲ ಕೋಡ್ ಮಾದರಿಯು 1C ಮೌಲ್ಯದ ಕೋಷ್ಟಕದ ಕಾಲಮ್‌ಗಳನ್ನು ಸಂಗ್ರಹವಾಗಿ ಎಣಿಸುತ್ತಿದೆ.

// MyTZ ನಿಂದ ಪ್ರತಿಯೊಂದು ಕಾಲಮ್‌ಗೆ TK ಯ ಎಲ್ಲಾ ಕಾಲಮ್‌ಗಳ ಹೆಸರುಗಳನ್ನು ಪ್ರದರ್ಶಿಸಿ.ಕಾಲಮ್‌ಗಳ ಸೈಕಲ್ ವರದಿ("ಕಾಲಮ್ ಹೆಸರು: " + Column.Name); ಎಂಡ್ಸೈಕಲ್;

ನಮ್ಮ ಸೈಕಲ್ ಎಲ್ಲಾ ಕಾಲಮ್ ಹೆಸರುಗಳನ್ನು 1C ಸಂದೇಶ ವಿಂಡೋದಲ್ಲಿ ಪ್ರದರ್ಶಿಸುತ್ತದೆ:

ಕಾಲಮ್ ಹೆಸರು: ಕೊನೆಯ ಹೆಸರು ಕಾಲಮ್ ಹೆಸರು: ಮೊದಲ ಹೆಸರು ಕಾಲಮ್ ಹೆಸರು: ಮಧ್ಯದ ಹೆಸರು

ಕಾಲಮ್‌ಗಳ ಮೂಲಕ ಪುನರಾವರ್ತನೆ ಮಾಡಲು, ಸಾಲು ಪುನರಾವರ್ತನೆಯ ಚಕ್ರದಂತೆಯೇ (ಹಿಂದಿನ ಲೇಖನದಲ್ಲಿ) ವಿಶೇಷ ಸಂಗ್ರಹ ಪುನರಾವರ್ತನೆಯ ಚಕ್ರವನ್ನು ಬಳಸಲಾಗುತ್ತದೆ ಎಂದು ನಾವು ನೋಡುತ್ತೇವೆ. MyTK.ಕಾಲಮ್‌ಗಳು- ಇದು 1C ಮೌಲ್ಯದ ಕೋಷ್ಟಕದ ಕಾಲಮ್‌ಗಳ ಸಂಗ್ರಹವಾಗಿದೆ "MyTZ". ಸಂಗ್ರಹವು ಪ್ರಕಾರದ ವಸ್ತುಗಳನ್ನು ಒಳಗೊಂಡಿದೆ "ಮೌಲ್ಯ ಕೋಷ್ಟಕದ ಕಾಲಮ್"ಈ ಪ್ರಕಾರದ ಪ್ರತಿಯೊಂದು ವಸ್ತುವು ಮೌಲ್ಯ ಕೋಷ್ಟಕದ ಕಾಲಮ್ ಆಗಿದೆ ಮತ್ತು ಗುಣಲಕ್ಷಣಗಳು ಮತ್ತು ವಿಧಾನಗಳನ್ನು ಒಳಗೊಂಡಿದೆ. ಈ ಗುಣಲಕ್ಷಣಗಳು ಮತ್ತು ವಿಧಾನಗಳನ್ನು ಪ್ರವೇಶಿಸುವ ಮೂಲಕ, ನಾವು ಒಂದು ಕಾಲಮ್ ಬಗ್ಗೆ ಅಗತ್ಯ ಮಾಹಿತಿಯನ್ನು ಪಡೆಯುತ್ತೇವೆ ಅಥವಾ ಅದರೊಂದಿಗೆ ಕೆಲವು ಇತರ ಕ್ರಿಯೆಗಳನ್ನು ಮಾಡುತ್ತೇವೆ.

ಉದಾಹರಣೆಗೆ, ಆಸ್ತಿಯನ್ನು ಪ್ರವೇಶಿಸುವುದು "ಹೆಸರು" (ಅಂಕಣ.ಹೆಸರು) ನಾವು ಪ್ರಸ್ತುತ ಕಾಲಮ್ನ ಹೆಸರನ್ನು ಪಡೆಯುತ್ತೇವೆ.

ಸರಣಿಯ ಶೀರ್ಷಿಕೆಗೆ ನಾನು ನಿಮ್ಮ ಗಮನವನ್ನು ಸೆಳೆಯಲು ಬಯಸುತ್ತೇನೆ: “ಎಲ್ಲರಿಗೂ ಅಂಕಣ MyTZ.ಕಾಲಮ್ ಸೈಕಲ್‌ನಿಂದ" ಹೆಸರಿನೊಂದಿಗೆ ವೇರಿಯೇಬಲ್ "ಕಾಲಮ್"ನಮ್ಮಿಂದ ಆವಿಷ್ಕರಿಸಲಾಗಿದೆ. ಅದೇ ಹೆಸರನ್ನು ಬಳಸುವುದು ಅನಿವಾರ್ಯವಲ್ಲ. ನೀವು ಈ ವೇರಿಯಬಲ್ ಅನ್ನು ನೀವು ಇಷ್ಟಪಡುವ ಯಾವುದನ್ನಾದರೂ ಕರೆಯಬಹುದು, ಉದಾಹರಣೆಗೆ "MyCurrentColumn"ನಂತರ ಮೇಲಿನ ಉದಾಹರಣೆಯು ಈ ರೀತಿ ಕಾಣುತ್ತದೆ:

// MyTK.ಕಾಲಮ್ಸ್ ಸೈಕಲ್ ವರದಿಯಿಂದ ಪ್ರತಿ MyCurrentColumn ಗೆ TK ಯ ಎಲ್ಲಾ ಕಾಲಮ್‌ಗಳ ಹೆಸರುಗಳನ್ನು ಪ್ರದರ್ಶಿಸಿ("ಕಾಲಮ್ ಹೆಸರು: " + MyCurrentColumn.Name); ಎಂಡ್ಸೈಕಲ್;

1C ಎಕ್ಸಿಕ್ಯೂಶನ್ ಉಪವ್ಯವಸ್ಥೆಯು ಈ ಪ್ರಕಾರದ ಚಕ್ರವನ್ನು ಎದುರಿಸಿದಾಗ, ಚಕ್ರದ ಪ್ರತಿಯೊಂದು ಪಾಸ್‌ನೊಂದಿಗೆ ಅದು ನಮ್ಮ ಸಂಗ್ರಹಣೆಯಿಂದ ಒಂದು ಅಂಶವನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಹೆಸರಿನೊಂದಿಗೆ ವೇರಿಯಬಲ್‌ಗೆ ನಿಯೋಜಿಸುತ್ತದೆ, ಈ ಸಂದರ್ಭದಲ್ಲಿ - ಒಂದು ಸಂಗ್ರಹ ಅಂಶಮೌಲ್ಯದ ಕೋಷ್ಟಕ ಕಾಲಮ್‌ಗಳು MyTK.ಕಾಲಮ್‌ಗಳುತದನಂತರ ನಾವು ಪ್ರಸ್ತುತ ಕಾಲಮ್ ಅನ್ನು ಹೊಂದಿರುವ ವೇರಿಯಬಲ್ ಅನ್ನು ಪ್ರವೇಶಿಸುತ್ತೇವೆ ಮತ್ತು ಆಸ್ತಿಯನ್ನು ಬಳಸುತ್ತೇವೆ "ಹೆಸರು".

ಕಾಲಮ್‌ಗಳ ಸಂಗ್ರಹದಲ್ಲಿ ಪ್ರತಿ ಕಾಲಮ್‌ನ ಸಂಖ್ಯೆಯನ್ನು ಕಾಲಮ್ ಹೆಸರಿನ ಮುಂದೆ ಪ್ರದರ್ಶಿಸಲು ನಾನು ಪ್ರಸ್ತಾಪಿಸುತ್ತೇನೆ:

// MyTZ ನಿಂದ ಪ್ರತಿ ಕಾಲಮ್‌ಗೆ ಮೌಲ್ಯಗಳ ಕೋಷ್ಟಕದ ಎಲ್ಲಾ ಕಾಲಮ್‌ಗಳ ಸಂಖ್ಯೆ ಮತ್ತು ಹೆಸರುಗಳನ್ನು ಪ್ರದರ್ಶಿಸಿ // ಕಾಲಮ್ ಸಂಖ್ಯೆಯನ್ನು ಪಡೆಯಿರಿ ColumnName = Column.Name; // ಕಾಲಮ್ ಹೆಸರು ವರದಿಯನ್ನು ಪಡೆಯಿರಿ ("ಕಾಲಮ್ ಸಂಖ್ಯೆ:" + ಕಾಲಮ್ ಸಂಖ್ಯೆ + "ಕಾಲಮ್ ಹೆಸರು: " + ಕಾಲಮ್ ಹೆಸರು); ಎಂಡ್ಸೈಕಲ್;

ಕೆಳಗಿನ ಪಠ್ಯವನ್ನು 1C ಸಂದೇಶ ವಿಂಡೋದಲ್ಲಿ ಪ್ರದರ್ಶಿಸಲಾಗುತ್ತದೆ:

ಕಾಲಮ್ ಸಂಖ್ಯೆ: 0 ಕಾಲಮ್ ಹೆಸರು: ಕೊನೆಯ ಹೆಸರು ಕಾಲಮ್ ಸಂಖ್ಯೆ: 1 ಕಾಲಮ್ ಹೆಸರು: ಮೊದಲ ಹೆಸರು ಕಾಲಮ್ ಸಂಖ್ಯೆ: 2 ಕಾಲಮ್ ಹೆಸರು: ಮಧ್ಯದ ಹೆಸರು

ಮೌಲ್ಯ ಕೋಷ್ಟಕದ ಸಾಲುಗಳಂತೆ 1C ಮೌಲ್ಯದ ಕೋಷ್ಟಕದಲ್ಲಿನ ಕಾಲಮ್‌ಗಳು ಶೂನ್ಯದಿಂದ ಪ್ರಾರಂಭವಾಗುತ್ತವೆ ಎಂಬುದನ್ನು ದಯವಿಟ್ಟು ಗಮನಿಸಿ.

1C ಮೌಲ್ಯದ ಕೋಷ್ಟಕದಲ್ಲಿನ ಕಾಲಮ್‌ಗಳ ಸಂಖ್ಯೆ

ಮೌಲ್ಯಗಳ ಕೋಷ್ಟಕದಲ್ಲಿನ ಕಾಲಮ್‌ಗಳ ಸಂಖ್ಯೆಯನ್ನು ಕಂಡುಹಿಡಿಯಲು, ನಾವು ಕಾಲಮ್‌ಗಳ ಸಂಗ್ರಹಣೆಯಲ್ಲಿ "ಎಣಿಕೆ ()" ವಿಧಾನವನ್ನು ಬಳಸುತ್ತೇವೆ.

ಅಂಕಣಗಳ ಸಂಖ್ಯೆ = MyTZ.Columns.Quantity(); ವರದಿ (ಕಾಲಮ್‌ಗಳ ಸಂಖ್ಯೆ);

ಪರದೆಯ ಮೇಲೆ "3" ಸಂಖ್ಯೆಯನ್ನು ಪ್ರದರ್ಶಿಸಲಾಗುತ್ತದೆ. ವಾಸ್ತವವಾಗಿ, ನಮ್ಮ ಟೇಬಲ್ ಮೂರು ಕಾಲಮ್ಗಳನ್ನು ಹೊಂದಿದೆ: "ಕೊನೆಯ ಹೆಸರು", "ಮೊದಲ ಹೆಸರು", "ಪೋಷಕ"

ಕಾಲಮ್ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಅದರ ಸಂಖ್ಯೆಯಿಂದ (ಸೂಚ್ಯಂಕ) ಪಡೆಯುವುದು ಮತ್ತು ಕಾಲಮ್ ಇಂಡೆಕ್ಸ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಕಾಲಮ್ಗಳನ್ನು ಎಣಿಸುವುದು

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

ಖಾತೆಗಾಗಿ = 0 MyTZ.Columns.Quantity() - 1 ಸೈಕಲ್ ಕರೆಂಟ್‌ಕಾಲಮ್ = MyTZ.ಕಾಲಮ್‌ಗಳು[ಆಕ್ಟ್]; ವರದಿ(ಪ್ರಸ್ತುತ ಕಾಲಮ್.ಹೆಸರು); ಎಂಡ್ಸೈಕಲ್;

ಪರದೆಯ ಮೇಲೆ ನಾವು ಈ ಕೆಳಗಿನವುಗಳನ್ನು ಪಡೆಯುತ್ತೇವೆ

ಪೂರ್ಣ ಹೆಸರು

ಈ ಉದಾಹರಣೆಯು ಸ್ಪಷ್ಟವಾಗಿದೆ ಎಂದು ನಾನು ಭಾವಿಸುತ್ತೇನೆ. ನಾವು ವಿಧಾನಕ್ಕೆ ತಿರುಗಿದ್ದೇವೆ ಪ್ರಮಾಣ()ಅಂಕಣ ಸಂಗ್ರಹಗಳು" MyTZ.Columns.Quantity()", ಕಾಲಮ್‌ಗಳ ಸಂಖ್ಯೆಯನ್ನು ಪಡೆದುಕೊಂಡಿದೆ ಮತ್ತು ಕೌಂಟರ್‌ನೊಂದಿಗೆ ಲೂಪ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಿದೆ ಶೂನ್ಯಮೊದಲು ಕಾಲಮ್‌ಗಳ ಸಂಖ್ಯೆ ಒಂದನ್ನು ಕಳೆದು. ಲೂಪ್ ಒಳಗೆ ನಾವು ಕಾಲಮ್ಗಳ ಸಂಗ್ರಹದಿಂದ ಪ್ರತಿ ಕಾಲಮ್ ಅನ್ನು ಪಡೆಯುತ್ತೇವೆ ಮತ್ತು ಪ್ರಸ್ತುತ ಕಾಲಮ್ ವಸ್ತುವನ್ನು ವೇರಿಯಬಲ್ಗೆ ನಿಯೋಜಿಸುತ್ತೇವೆ ಪ್ರಸ್ತುತ ಕಾಲಮ್ಮುಂದೆ, ವೇರಿಯಬಲ್ ಪ್ರಸ್ತುತ ಕಾಲಮ್ನಾವು ಆಸ್ತಿಯನ್ನು ಪ್ರವೇಶಿಸುತ್ತೇವೆ ಹೆಸರುಮತ್ತು ಪರದೆಯ ಮೇಲೆ ಈ ಆಸ್ತಿಯ ಮೌಲ್ಯವನ್ನು ಪ್ರದರ್ಶಿಸಿ: ವರದಿ(ಪ್ರಸ್ತುತ ಕಾಲಮ್.ಹೆಸರು);

ವಸ್ತುವಿನ ಆಸ್ತಿ ಮತ್ತು ವಸ್ತುವಿನ ವಿಧಾನವನ್ನು ಎಂದಿಗೂ ಗೊಂದಲಗೊಳಿಸದಿರುವುದು ಮುಖ್ಯವಾಗಿದೆ.

ಆಸ್ತಿಯು ಒಂದು ನಿರ್ದಿಷ್ಟ ಸ್ಥಿರ ಮೌಲ್ಯವಾಗಿದೆ ಮತ್ತು ಅದಕ್ಕೆ ಪ್ರವೇಶವನ್ನು ಆವರಣವಿಲ್ಲದೆ ಬರೆಯಲಾಗುತ್ತದೆ, ಉದಾಹರಣೆಗೆ ಪ್ರಸ್ತುತ ಕಾಲಮ್.ಹೆಸರು. ಒಂದು ವಿಧಾನವು ಮೂಲಭೂತವಾಗಿ ಒಂದು ವಸ್ತುವಿನ ಕಾರ್ಯವಿಧಾನ ಅಥವಾ ಕಾರ್ಯವಾಗಿದೆ, ಮತ್ತು ಕಾರ್ಯವಿಧಾನಗಳು ಮತ್ತು ಕಾರ್ಯಗಳಿಗೆ ಕರೆಗಳನ್ನು ಯಾವಾಗಲೂ ಆವರಣಗಳೊಂದಿಗೆ ಬರೆಯಲಾಗುತ್ತದೆ (ಯಾವುದೇ ಇನ್ಪುಟ್ ನಿಯತಾಂಕಗಳಿಲ್ಲದಿದ್ದರೂ ಸಹ). ಉದಾಹರಣೆಗೆ: MyTZ.Columns.Quantity()

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

ಒಂದು ವಿಧಾನದ ಕರೆಯಲ್ಲಿ ಆವರಣವನ್ನು ತಪ್ಪಾದ ರೀತಿಯಲ್ಲಿ ಹಾಕಲು ನಾನು ಮರೆತರೆ ಇಂಟರ್ಪ್ರಿಟರ್ ಬರೆಯುವುದು ಇದನ್ನೇ MyTZ.Columns.Quantity("ಪ್ರಮಾಣ()" ನಂತರ ಆವರಣವಿಲ್ಲದೆ):

ವಸ್ತು ಕ್ಷೇತ್ರ ಕಂಡುಬಂದಿಲ್ಲ (ಪ್ರಮಾಣ)

ಈ ಸಂದರ್ಭದಲ್ಲಿ, "ಕ್ಷೇತ್ರ" ಮತ್ತು "ಆಸ್ತಿ" ಅನ್ನು ಸಮಾನಾರ್ಥಕಗಳಾಗಿ ಅರ್ಥೈಸಿಕೊಳ್ಳಬೇಕು, ಅಥವಾ 1C ಡೆವಲಪರ್‌ಗಳ ಪರಿಭಾಷೆಯಲ್ಲಿನ ತಪ್ಪಾಗಿದೆ. ಅವರು ಒಂದೇ ಪರಿಕಲ್ಪನೆಯನ್ನು ಉಲ್ಲೇಖಿಸಲು ಈ ಎರಡೂ ಪದಗಳನ್ನು ಬಳಸುತ್ತಾರೆ. ಇತರ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳಲ್ಲಿ ಈ ಪದಗಳು ವಿಭಿನ್ನ ವಿಷಯಗಳನ್ನು ಅರ್ಥೈಸಬಲ್ಲವು.

ಕಾಲಮ್ ಸಂಖ್ಯೆಗಳನ್ನು ಬಳಸಿಕೊಂಡು 1C ಮೌಲ್ಯಗಳ ಕೋಷ್ಟಕದಿಂದ ಡೇಟಾವನ್ನು ಪಡೆಯುವುದು

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

ಮೊದಲ ಸಾಲು = MyTK; // ಮೊದಲ ಸಾಲನ್ನು ಪಡೆಯಿರಿ (ಶೂನ್ಯದಿಂದ ಸಂಖ್ಯೆ) FirstColumnValue = FirstRow; // ಮೊದಲ ಕಾಲಮ್‌ನ ಮೌಲ್ಯವನ್ನು ಪಡೆಯಿರಿ (ಕಾಲಮ್ ನಂಬರಿಂಗ್ ಸಹ ಮೊದಲಿನಿಂದಲೂ ಇದೆ) ವರದಿ (ಮೊದಲ ಕಾಲಮ್‌ನ ಮೌಲ್ಯ); // ಟೇಬಲ್‌ನ ಮೊದಲ ಸಾಲಿನಲ್ಲಿ ಮೊದಲ ಕಾಲಮ್‌ನ ಮೌಲ್ಯವನ್ನು ಪ್ರದರ್ಶಿಸಿ

ಪರದೆಯು ಪ್ರದರ್ಶಿಸುತ್ತದೆ:

ಚಾಪೇವ್

[...] ಆಪರೇಟರ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಮೌಲ್ಯ ಕೋಷ್ಟಕವನ್ನು ಪ್ರವೇಶಿಸುವ ಮೂಲಕ ನಾವು ಮೊದಲು ಮೌಲ್ಯದ ಕೋಷ್ಟಕದ ಸಾಲು ವಸ್ತುವನ್ನು ಪಡೆದುಕೊಂಡಿದ್ದೇವೆ. (ಇದನ್ನು ಹೇಗೆ ಮಾಡಬೇಕೆಂದು ನೀವು ಮರೆತಿದ್ದರೆ, ನೀವು ಹಿಂದಿನ ಲೇಖನಗಳನ್ನು ನೋಡಬಹುದು) ನಾವು ಆಪರೇಟರ್ ಒಳಗೆ "0" ವಾದವನ್ನು ರವಾನಿಸಿದ್ದೇವೆ. ಇದು ಮೌಲ್ಯದ ಕೋಷ್ಟಕದ ಮೊದಲ ಸಾಲಿನ ಸೂಚ್ಯಂಕವಾಗಿದೆ. ಮೊದಲ ಸಾಲು = MyTK;

ಇದಲ್ಲದೆ, [...] ಆಪರೇಟರ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಸ್ಟ್ರಿಂಗ್ ವಸ್ತುವನ್ನು ಪ್ರವೇಶಿಸುವ ಹಕ್ಕನ್ನು ನಾವು ಹೊಂದಿದ್ದೇವೆ. ಈ ಆಪರೇಟರ್ ಒಳಗೆ ನಾವು ಮೌಲ್ಯ ಕೋಷ್ಟಕದ ಕಾಲಮ್ ಸಂಖ್ಯೆಯನ್ನು ರವಾನಿಸಿದ್ದೇವೆ, ಈ ಸಂದರ್ಭದಲ್ಲಿ "0" ಸಹ. ಹೀಗಾಗಿ, ಪ್ರಸ್ತುತ ಕೋಷ್ಟಕದ ಸಾಲಿಗೆ "0" ಸಂಖ್ಯೆಯ ಕಾಲಮ್‌ನ ಮೌಲ್ಯವನ್ನು ನಾವು ಸ್ವೀಕರಿಸಿದ್ದೇವೆ. ನಾವು ಈ ಮೌಲ್ಯವನ್ನು ಪರದೆಯ ಮೇಲೆ ಪ್ರದರ್ಶಿಸಿದ್ದೇವೆ ಮತ್ತು ಅದು "ಚಾಪೇವ್" ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ.

ನಮ್ಮ ಉದಾಹರಣೆಯನ್ನು ಸ್ವಲ್ಪ ಸಂಕೀರ್ಣಗೊಳಿಸೋಣ:

ಮೊದಲ ಸಾಲು = MyTK; // ಮೊದಲ ಸಾಲನ್ನು ಪಡೆಯಿರಿ (ಶೂನ್ಯದಿಂದ ಸಂಖ್ಯೆ) ವರದಿ (ಮೊದಲ ಸಾಲು); // ಟೇಬಲ್‌ನ ಮೊದಲ ಸಾಲಿನಲ್ಲಿ ಮೊದಲ ಕಾಲಮ್‌ನ ಮೌಲ್ಯವನ್ನು ಪ್ರದರ್ಶಿಸಿ ವರದಿ (ಮೊದಲ ಸಾಲು); // ಟೇಬಲ್‌ನ ಮೊದಲ ಸಾಲಿನಲ್ಲಿ ಎರಡನೇ ಕಾಲಮ್‌ನ ಮೌಲ್ಯವನ್ನು ಪ್ರದರ್ಶಿಸಿ ವರದಿ (ಮೊದಲ ಸಾಲು); // ಟೇಬಲ್‌ನ ಮೊದಲ ಸಾಲಿನಲ್ಲಿ ಮೂರನೇ ಕಾಲಮ್‌ನ ಮೌಲ್ಯವನ್ನು ಪ್ರದರ್ಶಿಸಿ

ನಾವು ಈಗ ನಮ್ಮ ಮೌಲ್ಯ ಕೋಷ್ಟಕದ ಮೊದಲ ಸಾಲಿನ ಎಲ್ಲಾ ಮೂರು ಕಾಲಮ್‌ಗಳಿಂದ ಮೌಲ್ಯಗಳನ್ನು ಪ್ರದರ್ಶಿಸಿದ್ದೇವೆ:

ಚಾಪೇವ್ ವಾಸಿಲಿ ಇವನೊವಿಚ್

ಈಗ ನಾನು ಈ ಉದಾಹರಣೆಯನ್ನು ಮಾರ್ಪಡಿಸುತ್ತೇನೆ ಇದರಿಂದ ನಾವು ವೇರಿಯಬಲ್ ಇಲ್ಲದೆ ಮಾಡಬಹುದು "ಮೊದಲ ಸಾಲು"

ವರದಿ(MyTZ); // ಟೇಬಲ್‌ನ ಮೊದಲ ಸಾಲಿನಲ್ಲಿ ಮೊದಲ ಕಾಲಮ್‌ನ ಮೌಲ್ಯವನ್ನು ಪ್ರದರ್ಶಿಸಿ ವರದಿ(MyTZ); // ವರದಿ (MyTZ) ಕೋಷ್ಟಕದ ಮೊದಲ ಸಾಲಿನಲ್ಲಿ ಎರಡನೇ ಕಾಲಮ್‌ನ ಮೌಲ್ಯವನ್ನು ಪ್ರದರ್ಶಿಸಿ; // ಟೇಬಲ್‌ನ ಮೊದಲ ಸಾಲಿನಲ್ಲಿ ಮೂರನೇ ಕಾಲಮ್‌ನ ಮೌಲ್ಯವನ್ನು ಪ್ರದರ್ಶಿಸಿ

ಪರದೆಯ ಮೇಲೂ ಅದೇ ಆಗಿರುತ್ತದೆ

ಚಾಪೇವ್ ವಾಸಿಲಿ ಇವನೊವಿಚ್

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

ಆದ್ದರಿಂದ, ನಾವು ಲೂಪ್ ರಚಿಸಲು ಸಿದ್ಧರಿದ್ದೇವೆ ಮತ್ತು ಸಾಲು ಮತ್ತು ಕಾಲಮ್ ಸೂಚ್ಯಂಕಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಎಲ್ಲಾ ಸಾಲುಗಳು ಮತ್ತು ಎಲ್ಲಾ ಕಾಲಮ್‌ಗಳ ಡೇಟಾವನ್ನು ಪಡೆಯಲು ನಾವು ಸಿದ್ಧರಿದ್ದೇವೆ:

RowCounter ಗಾಗಿ = 0 MyTZ ಮೂಲಕ.Quantity() - 1 ಲೂಪ್ // ಕಾಲಮ್‌ಕೌಂಟರ್‌ಗಾಗಿ // ಸೈಕಲ್ ಮೂಲಕ ಕಾಲಮ್‌ಕೌಂಟರ್ = 0 MyTZ.Columns.Quantity() - 1 ಲೂಪ್ // ಕಾಲಮ್‌ಗಳ ಮೂಲಕ ನೆಸ್ಟೆಡ್ ಲೂಪ್ // ಸೆಲ್ ಮೌಲ್ಯವನ್ನು ಪಡೆಯಿರಿ (ಪ್ರಸ್ತುತ ಸಾಲಿನಿಂದ ಮತ್ತು ಪ್ರಸ್ತುತ ಕಾಲಮ್‌ಗಳು) CellValue = MyTK[RowCounter][ColumnCounter]; // ಸಾಲು ಸಂಖ್ಯೆ, ಕಾಲಮ್ ಸಂಖ್ಯೆ ಮತ್ತು ಸೆಲ್ ಮೌಲ್ಯ ವರದಿಯನ್ನು ಪ್ರದರ್ಶಿಸಿ ("ಸಾಲು ಸಂಖ್ಯೆ" + ಸಾಲು ಎಣಿಕೆ + "ಕಾಲಮ್ ಸಂಖ್ಯೆ" + ಕಾಲಮ್ ಎಣಿಕೆ + " = " + ಸೆಲ್ ಮೌಲ್ಯ); ಎಂಡ್ಸೈಕಲ್; ಎಂಡ್ಸೈಕಲ್;

ಕೆಳಗಿನವುಗಳನ್ನು ಪರದೆಯ ಮೇಲೆ ಪ್ರದರ್ಶಿಸಲಾಗುತ್ತದೆ:

ಸಾಲು ಸಂಖ್ಯೆ 0 ಕಾಲಮ್ ಸಂಖ್ಯೆ 0 = ಚಾಪೇವ್ ಲೈನ್ ಸಂಖ್ಯೆ 0 ಕಾಲಮ್ ಸಂಖ್ಯೆ 1 = ವಾಸಿಲಿ ಲೈನ್ ಸಂಖ್ಯೆ 0 ಕಾಲಮ್ ಸಂಖ್ಯೆ 2 = ಇವನೊವಿಚ್ ಲೈನ್ ಸಂಖ್ಯೆ 1 ಕಾಲಮ್ ಸಂಖ್ಯೆ 0 = ಡಿಜೆರ್ಜಿನ್ಸ್ಕಿ ಲೈನ್ ಸಂಖ್ಯೆ 1 ಕಾಲಮ್ ಸಂಖ್ಯೆ 1 = ಫೆಲಿಕ್ಸ್ ಸಾಲು ಸಂಖ್ಯೆ 1 ಕಾಲಮ್ ಸಂಖ್ಯೆ 2 = ಎಡ್ಮಂಡೋವಿಚ್ ಲೈನ್ ಸಂಖ್ಯೆ 2 ಕಾಲಮ್ ಸಂಖ್ಯೆ 0 = ಕೊಟೊವ್ಸ್ಕಿ ಲೈನ್ ಸಂಖ್ಯೆ 2 ಕಾಲಮ್ ಸಂಖ್ಯೆ 1 = ಗ್ರಿಗರಿ ಲೈನ್ ಸಂಖ್ಯೆ 2 ಕಾಲಮ್ ಸಂಖ್ಯೆ 2 = ಇವನೊವಿಚ್

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

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

ಲೈನ್‌ಕೌಂಟರ್‌ಗಾಗಿ = 0 MyTZ ಮೂಲಕ.Quantity() - 1 ಲೂಪ್ // ಸಾಲುಗಳ ಮೂಲಕ ಲೂಪ್ ವರದಿ(" ======= ಲೈನ್ ಸಂಖ್ಯೆ. " + ಲೈನ್‌ಕೌಂಟರ್ + " ========"); ವರದಿ ಮಾಡಲು(" "); // ಲೈನ್ ಫೀಡ್ (ಸೇರಿಸು ಖಾಲಿ ಸಾಲು) ಕಾಲಮ್‌ಕೌಂಟರ್‌ಗಾಗಿ = 0 MyTZ ಮೂಲಕ // ಕಾಲಮ್‌ನ ಹೆಸರನ್ನು ಪಡೆಯಿರಿ ColumnName = MyTZ.Columns[ColumnCounter].Name; // ಕಾಲಮ್ ಹೆಸರು ಮತ್ತು ಸೆಲ್ ಮೌಲ್ಯವನ್ನು ಪ್ರದರ್ಶಿಸಿ ವರದಿ(ColumnName + ": " + CellValue); ಎಂಡ್ಸೈಕಲ್; ವರದಿ ಮಾಡಲು(" "); // ಲೈನ್ ಫೀಡ್ (ಖಾಲಿ ರೇಖೆಯನ್ನು ಸೇರಿಸುವುದು) EndCycle;

ಈಗ, ನಮ್ಮ ಪರದೆಯ ಮೇಲೆ ಮಾಹಿತಿಯು ಹೆಚ್ಚು ಪ್ರಾತಿನಿಧಿಕವಾಗಿ ಕಾಣಲಾರಂಭಿಸಿತು:

ಸಾಲು ಸಂಖ್ಯೆ 0 ======= ಕೊನೆಯ ಹೆಸರು: ಚಾಪೇವ್ ಮೊದಲ ಹೆಸರು: ವಾಸಿಲಿ ಪೋಷಕ: ಇವನೊವಿಚ್ ======= ಸಾಲು ಸಂಖ್ಯೆ 1 ======= ಕೊನೆಯ ಹೆಸರು: ಡಿಜೆರ್ಜಿನ್ಸ್ಕಿ ಮೊದಲ ಹೆಸರು: ಫೆಲಿಕ್ಸ್ ಪೋಷಕ: ಎಡ್ಮಂಡೋವಿಚ್ ===== == ಸಾಲು ಸಂಖ್ಯೆ 2 ====== ಕೊನೆಯ ಹೆಸರು: ಕೊಟೊವ್ಸ್ಕಿ ಮೊದಲ ಹೆಸರು: ಗ್ರಿಗರಿ ಪೋಷಕ: ಇವನೊವಿಚ್

ಹೌದು, ನಾನು ಬಹುತೇಕ ಮರೆತಿದ್ದೇನೆ. ಸತತವಾಗಿ ಎರಡು [...][...] ಆಪರೇಟರ್‌ಗಳನ್ನು ಬಳಸುವಾಗ, ಕಾಲಮ್ ಇಂಡೆಕ್ಸ್‌ನ ಬದಲಿಗೆ ನಾವು ಈ ಕಾಲಮ್‌ನ ಹೆಸರನ್ನು ರವಾನಿಸಬಹುದು: ಮೌಲ್ಯಪಟ್ಟಿ[ಸಾಲು ಸೂಚ್ಯಂಕ] [ಕಾಲಮ್ ಹೆಸರು]

ಲೈನ್‌ಕೌಂಟರ್‌ಗಾಗಿ = 0 MyTZ ಮೂಲಕ.Quantity() - 1 ಲೂಪ್ // ಸಾಲುಗಳ ಮೂಲಕ ಲೂಪ್ ವರದಿ(" ======= ಲೈನ್ ಸಂಖ್ಯೆ. " + ಲೈನ್‌ಕೌಂಟರ್ + " ======== "); ವರದಿ ಮಾಡಲು(" "); // ಲೈನ್ ಫೀಡ್ (ಖಾಲಿ ಸಾಲನ್ನು ಸೇರಿಸುವುದು) ಕಾಲಮ್‌ಕೌಂಟರ್‌ಗಾಗಿ = 0 MyTZ.Columns.Quantity() - 1 ಲೂಪ್ // ಕಾಲಮ್‌ಗಳ ಮೂಲಕ ನೆಸ್ಟೆಡ್ ಲೂಪ್ ColumnName = MyTZ.Columns[ColumnCounter].Name; // ಕಾಲಮ್ ಹೆಸರನ್ನು ಪಡೆಯಿರಿ ಸೆಲ್ ಮೌಲ್ಯ = MyTZ[RowCounter][ColumnName]; //

ಬಾಣದಿಂದ ಗುರುತಿಸಲಾದ ಸಾಲಿಗೆ ಗಮನ ಕೊಡಿ ". ಈ ಸಾಲಿನಲ್ಲಿ, ಪ್ರಸ್ತುತ ಕಾಲಮ್‌ನ ಸೂಚ್ಯಂಕದ ಬದಲಿಗೆ, ನಾವು ಪ್ರಸ್ತುತ ಕಾಲಮ್‌ನ ಹೆಸರನ್ನು ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗೆ ರವಾನಿಸುತ್ತೇವೆ ಚೌಕ ಆವರಣ[...] ಫಲಿತಾಂಶವು ಒಂದೇ ಆಗಿರುತ್ತದೆ.

ಮತ್ತು ಈಗ, ಈ ಲೇಖನದಲ್ಲಿ ಕೊನೆಯ ವಿಷಯ.

ಸಾಲುಗಳ ಸಂಗ್ರಹ ಮತ್ತು ಕಾಲಮ್‌ಗಳ ಸಂಗ್ರಹದ ಮೂಲಕ ಲೂಪ್‌ಗಳನ್ನು ಬಳಸಿಕೊಂಡು 1C ಮೌಲ್ಯದ ಕೋಷ್ಟಕದಿಂದ ಎಲ್ಲಾ ಡೇಟಾವನ್ನು ಸರಿಯಾಗಿ ಪಡೆಯುವುದು

MyTZ ಲೂಪ್‌ನಿಂದ ಪ್ರತಿ ಕರೆಂಟ್‌ಲೈನ್‌ಗಾಗಿ // ಸ್ಟ್ರಿಂಗ್‌ಗಳ ಸಂಗ್ರಹದ ಮೂಲಕ ಲೂಪ್ ವರದಿ(" ======= ಲೈನ್ ಸಂಖ್ಯೆ. " + MyTZ.Index(CurrentLine) + " ========"); ವರದಿ ಮಾಡಲು(" "); MyTZ. ಕಾಲಮ್‌ಗಳ ಲೂಪ್‌ನಿಂದ ಪ್ರತಿ ಪ್ರಸ್ತುತ ಕಾಲಮ್‌ಗೆ // ಕಾಲಮ್‌ಗಳ ಸಂಗ್ರಹಣೆಯ ಮೂಲಕ ನೆಸ್ಟೆಡ್ ಲೂಪ್ ಪುನರಾವರ್ತನೆಯಾಗುತ್ತದೆ ColumnName = CurrentColumn.Name; // ಕಾಲಮ್ ಹೆಸರನ್ನು ಪಡೆಯಿರಿCellValue = CurrentRow[ColumnName]; // ಕಾಲಮ್ NAME ವರದಿಯಿಂದ ಸೆಲ್ ಮೌಲ್ಯವನ್ನು ಪಡೆಯಿರಿ(ಕಾಲಮ್ ಹೆಸರು + ": " + CellValue); // ಕಾಲಮ್ ಹೆಸರು ಮತ್ತು ಸೆಲ್ ಮೌಲ್ಯವನ್ನು ಪ್ರದರ್ಶಿಸಿ ಸೈಕಲ್ ಅಂತ್ಯ; ವರದಿ ಮಾಡಲು(" "); ಎಂಡ್ಸೈಕಲ್;

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

ಅಂತಿಮವಾಗಿ, ಮಧ್ಯಂತರ ವೇರಿಯಬಲ್‌ಗಳ ಬಳಕೆಯನ್ನು ತೆಗೆದುಹಾಕುವ ಮೂಲಕ ನಮ್ಮ ಕೊನೆಯ ಉದಾಹರಣೆಯಲ್ಲಿ ಕೋಡ್‌ನ ಸಾಲುಗಳ ಸಂಖ್ಯೆಯನ್ನು ನಾನು ಸಾಧ್ಯವಾದಷ್ಟು ಕಡಿಮೆಗೊಳಿಸುತ್ತೇನೆ. ನೈಜ ಸಮಸ್ಯೆಗಳಲ್ಲಿ ಬಳಸಲಾಗುವ "ಕೈಗಾರಿಕಾ ಕೋಡ್" ನ ಮಾದರಿಯನ್ನು ನಾವು ಪಡೆಯುತ್ತೇವೆ.

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

MyTZ ಸೈಕಲ್‌ನಿಂದ ಪ್ರತಿ ಕರೆಂಟ್‌ಲೈನ್‌ಗೆ // ಸಾಲುಗಳ ಮೇಲೆ ಪುನರಾವರ್ತಿಸಿ ವರದಿ(" ======= ಲೈನ್ ಸಂಖ್ಯೆ. " + MyTZ.Index(CurrentLine) + " =========" + ಚಿಹ್ನೆಗಳು.PS); MyTZ. ಕಾಲಮ್‌ಗಳ ಲೂಪ್‌ನಿಂದ ಪ್ರತಿ ಪ್ರಸ್ತುತ ಕಾಲಮ್‌ಗೆ // ಕಾಲಮ್‌ಗಳ ಮೇಲೆ ಪುನರಾವರ್ತಿಸಿ ವರದಿ(CurrentColumn.Name + ": " + CurrentRow[CurrentColumn.Name]); ಎಂಡ್ಸೈಕಲ್; ವರದಿ ಮಾಡಲು(" "); ಎಂಡ್ಸೈಕಲ್;

ಪರದೆಯ ಮೇಲಿನ ಔಟ್‌ಪುಟ್ ಬದಲಾಗಿಲ್ಲ, ಇದು ಹಿಂದಿನ ಉದಾಹರಣೆಯಂತೆಯೇ ಇರುತ್ತದೆ:

2 ವಾರದ ಕೋರ್ಸ್

"ಆರಂಭಿಕರಿಗೆ 1C ನಲ್ಲಿ ಪ್ರೋಗ್ರಾಮಿಂಗ್"

ಕೋರ್ಸ್ ಗೆ ಬರಲಿದೆ ಇಮೇಲ್. ಹಂತ-ಹಂತದ ಕಾರ್ಯಗಳನ್ನು ಪೂರ್ಣಗೊಳಿಸುವ ಮೂಲಕ ಪ್ರೋಗ್ರಾಮರ್ ಆಗಿ.

ಭಾಗವಹಿಸಲು ನಿಮಗೆ ಕಂಪ್ಯೂಟರ್ ಮತ್ತು ಇಂಟರ್ನೆಟ್ ಮಾತ್ರ ಅಗತ್ಯವಿದೆ

ಕೋರ್ಸ್‌ಗೆ ಉಚಿತ ಪ್ರವೇಶ:

Sp-force-hide (ಪ್ರದರ್ಶನ: ಯಾವುದೂ ಇಲ್ಲ;).sp-ಫಾರ್ಮ್ (ಪ್ರದರ್ಶನ: ಬ್ಲಾಕ್; ಹಿನ್ನೆಲೆ: #eff2f4; ಪ್ಯಾಡಿಂಗ್: 5px; ಅಗಲ: 270px; ಗರಿಷ್ಠ-ಅಗಲ: 100%; ಗಡಿ-ತ್ರಿಜ್ಯ: 0px; -moz-ಗಡಿ -ತ್ರಿಜ್ಯ: 0px; -ವೆಬ್‌ಕಿಟ್-ಬಾರ್ಡರ್-ತ್ರಿಜ್ಯ: 0px; ಫಾಂಟ್-ಕುಟುಂಬ: ಏರಿಯಲ್, "ಹೆಲ್ವೆಟಿಕಾ ನ್ಯೂಯು", ಸಾನ್ಸ್-ಸೆರಿಫ್; ಹಿನ್ನೆಲೆ-ಪುನರಾವರ್ತನೆ: ಪುನರಾವರ್ತನೆ ಇಲ್ಲ; ಹಿನ್ನೆಲೆ-ಸ್ಥಾನ: ಕೇಂದ್ರ; ಹಿನ್ನೆಲೆ-ಗಾತ್ರ: ಸ್ವಯಂ;) .sp-ಫಾರ್ಮ್ ಇನ್‌ಪುಟ್ (ಪ್ರದರ್ಶನ: ಇನ್‌ಲೈನ್-ಬ್ಲಾಕ್; ಅಪಾರದರ್ಶಕತೆ: 1; ಗೋಚರತೆ: ಗೋಚರ;).sp-ಫಾರ್ಮ್ .sp-form-fields-wrapper (ಅಂಚು: 0 ಸ್ವಯಂ; ಅಗಲ: 260px;).sp-ಫಾರ್ಮ್ .sp -ಫಾರ್ಮ್-ಕಂಟ್ರೋಲ್ (ಹಿನ್ನೆಲೆ: #ffffff; ಗಡಿ-ಬಣ್ಣ: #cccccc; ಗಡಿ-ಶೈಲಿ: ಘನ; ಗಡಿ-ಅಗಲ: 1px; ಫಾಂಟ್-ಗಾತ್ರ: 15px; ಪ್ಯಾಡಿಂಗ್-ಎಡ: 8.75px; ಪ್ಯಾಡಿಂಗ್-ಬಲ: 8.75px; ಗಡಿ -ತ್ರಿಜ್ಯ: 4px; -moz-ಬಾರ್ಡರ್-ತ್ರಿಜ್ಯ: 4px; -ವೆಬ್ಕಿಟ್-ಬಾರ್ಡರ್-ತ್ರಿಜ್ಯ: 4px; ಎತ್ತರ: 35px; ಅಗಲ: 100%;).sp-ಫಾರ್ಮ್ .sp-ಫೀಲ್ಡ್ ಲೇಬಲ್ (ಬಣ್ಣ: #444444; ಫಾಂಟ್- ಗಾತ್ರ: 13px; ಫಾಂಟ್-ಶೈಲಿ: ಸಾಮಾನ್ಯ; ಫಾಂಟ್-ತೂಕ: ದಪ್ಪ;).sp-ಫಾರ್ಮ್ .sp-ಬಟನ್ (ಅಡಿಗೆ-ತ್ರಿಜ್ಯ: 4px; -moz-ಬಾರ್ಡರ್-ತ್ರಿಜ್ಯ: 4px; -webkit-border-radius: 4px; ಹಿನ್ನೆಲೆ-ಬಣ್ಣ: #f4394c; ಬಣ್ಣ: #ffffff; ಅಗಲ: 100%; ಫಾಂಟ್-ತೂಕ: 700; ಫಾಂಟ್ ಶೈಲಿ: ಸಾಮಾನ್ಯ; ಫಾಂಟ್-ಕುಟುಂಬ: ಏರಿಯಲ್, "ಹೆಲ್ವೆಟಿಕಾ ನ್ಯೂಯು", ಸಾನ್ಸ್-ಸೆರಿಫ್; ಬಾಕ್ಸ್ ನೆರಳು: ಯಾವುದೂ ಇಲ್ಲ; -moz-box-ನೆರಳು: ಯಾವುದೂ ಇಲ್ಲ; -ವೆಬ್ಕಿಟ್-ಬಾಕ್ಸ್-ನೆರಳು: ಯಾವುದೂ ಇಲ್ಲ; ಹಿನ್ನೆಲೆ: ರೇಖೀಯ-ಗ್ರೇಡಿಯಂಟ್(ಮೇಲಕ್ಕೆ, #e30d22 , #f77380);).sp-ಫಾರ್ಮ್ .sp-ಬಟನ್-ಕಂಟೇನರ್ (ಪಠ್ಯ-ಜೋಡಣೆ: ಕೇಂದ್ರ; ಅಗಲ: ಸ್ವಯಂ;)

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

ಒಂದು ಟೇಬಲ್ ಗೋದಾಮಿನಿಂದ ಸಾಗಿಸಬೇಕಾದ ಸರಕುಗಳನ್ನು ಪಟ್ಟಿ ಮಾಡುತ್ತದೆ. ಮತ್ತೊಂದು ಕೋಷ್ಟಕವು ಈ ಸರಕುಗಳಿಗೆ ಪಾವತಿಸುವ ಜವಾಬ್ದಾರಿಗಳನ್ನು ತೋರಿಸುತ್ತದೆ.

ಆದ್ದರಿಂದ, 1C ಯಲ್ಲಿ, ಕೋಷ್ಟಕಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವುದು ಪ್ರಮುಖ ಸ್ಥಳವನ್ನು ಆಕ್ರಮಿಸುತ್ತದೆ.

1C ಯಲ್ಲಿನ ಕೋಷ್ಟಕಗಳನ್ನು "ಕೋಷ್ಟಕ ಭಾಗಗಳು" ಎಂದೂ ಕರೆಯಲಾಗುತ್ತದೆ. ಡೈರೆಕ್ಟರಿಗಳು, ದಾಖಲೆಗಳು ಮತ್ತು ಇತರರು ಅವುಗಳನ್ನು ಹೊಂದಿದ್ದಾರೆ.

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

ಮೊದಲ - ವೇಗವಾಗಿ - ಆಯ್ಕೆ, ಅದರಿಂದ ಸಾಲುಗಳನ್ನು ಪಡೆಯುವುದು ಕ್ರಮದಲ್ಲಿ ಮಾತ್ರ ಸಾಧ್ಯ. ಎರಡನೆಯದು ಪ್ರಶ್ನೆಯ ಫಲಿತಾಂಶವನ್ನು ಮೌಲ್ಯಗಳ ಕೋಷ್ಟಕಕ್ಕೆ ಅಪ್‌ಲೋಡ್ ಮಾಡುವುದು ಮತ್ತು ನಂತರ ಅದಕ್ಕೆ ಯಾದೃಚ್ಛಿಕ ಪ್ರವೇಶ.

//ಆಯ್ಕೆ 1 - ಪ್ರಶ್ನೆ ಫಲಿತಾಂಶಗಳಿಗೆ ಅನುಕ್ರಮ ಪ್ರವೇಶ

//ಟೇಬಲ್ ಪಡೆಯಿರಿ
ಆಯ್ಕೆ = Query.Run().Select();
// ನಾವು ಪ್ರಶ್ನೆಯ ಫಲಿತಾಂಶದ ಎಲ್ಲಾ ಸಾಲುಗಳ ಮೂಲಕ ಕ್ರಮವಾಗಿ ಹೋಗುತ್ತೇವೆ
ಆಯ್ಕೆ ಮಾಡುವಾಗ.ಮುಂದೆ() ಲೂಪ್
ವರದಿ(ಆಯ್ಕೆ.ಹೆಸರು);
ಎಂಡ್ಸೈಕಲ್;

//ಆಯ್ಕೆ 2 - ಮೌಲ್ಯಗಳ ಟೇಬಲ್‌ಗೆ ಅಪ್‌ಲೋಡ್ ಮಾಡಲಾಗುತ್ತಿದೆ
ವಿನಂತಿ = ಹೊಸ ವಿನಂತಿ ("ಡೈರೆಕ್ಟರಿಯಿಂದ ಹೆಸರನ್ನು ಆಯ್ಕೆಮಾಡಿ. ನಾಮಕರಣ");
//ಟೇಬಲ್ ಪಡೆಯಿರಿ
ಟೇಬಲ್ = Query.Run().Unload().
//ಮುಂದೆ ನಾವು ಎಲ್ಲಾ ಸಾಲುಗಳ ಮೂಲಕವೂ ಪುನರಾವರ್ತಿಸಬಹುದು
ಟೇಬಲ್ ಸೈಕಲ್‌ನಿಂದ ಪ್ರತಿ ಸಾಲಿಗೆ
ವರದಿ(ಸ್ಟ್ರಿಂಗ್.ಹೆಸರು);
ಎಂಡ್ಸೈಕಲ್;
//ಅಥವಾ ನಿರಂಕುಶವಾಗಿ ತಂತಿಗಳನ್ನು ಪ್ರವೇಶಿಸಿ
ಸಾಲು = ಟೇಬಲ್.ಫೈಂಡ್("ಸಲಿ", "ಹೆಸರು");

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

ಫಾರ್ಮ್‌ನಲ್ಲಿ ಟೇಬಲ್ (ದಪ್ಪ ಕ್ಲೈಂಟ್)

ಫಾರ್ಮ್‌ನಲ್ಲಿ ಇರಿಸಿದಾಗ ಬಳಕೆದಾರರು ಟೇಬಲ್‌ನೊಂದಿಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಾರೆ.

ಪಾಠದಲ್ಲಿ ಮತ್ತು ಪಾಠದಲ್ಲಿ ರೂಪಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವ ಮೂಲ ತತ್ವಗಳನ್ನು ನಾವು ಚರ್ಚಿಸಿದ್ದೇವೆ

ಆದ್ದರಿಂದ, ಫಾರ್ಮ್ನಲ್ಲಿ ಟೇಬಲ್ ಅನ್ನು ಇರಿಸೋಣ. ಇದನ್ನು ಮಾಡಲು, ನೀವು ನಿಯಂತ್ರಣ ಫಲಕದಿಂದ ಟೇಬಲ್ ಅನ್ನು ಎಳೆಯಬಹುದು. ಅಂತೆಯೇ, ನೀವು ಮೆನುವಿನಿಂದ ಫಾರ್ಮ್/ಇನ್ಸರ್ಟ್ ಕಂಟ್ರೋಲ್ ಅನ್ನು ಆಯ್ಕೆ ಮಾಡಬಹುದು.

ಡೇಟಾವನ್ನು ಕಾನ್ಫಿಗರೇಶನ್‌ನಲ್ಲಿ ಸಂಗ್ರಹಿಸಬಹುದು - ನಂತರ ನೀವು ಸಂರಚನಾ ವಸ್ತುವಿನ ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ (ಹಿಂದೆ ಸೇರಿಸಲಾದ) ಕೋಷ್ಟಕ ಭಾಗವನ್ನು ನೀವು ಸಂಪಾದಿಸುವ ಫಾರ್ಮ್ ಅನ್ನು ಆಯ್ಕೆ ಮಾಡಬೇಕಾಗುತ್ತದೆ.

ಡೇಟಾ ಆಸ್ತಿಯಲ್ಲಿ "..." ಬಟನ್ ಕ್ಲಿಕ್ ಮಾಡಿ. ಪಟ್ಟಿಯನ್ನು ನೋಡಲು ಕೋಷ್ಟಕ ಭಾಗಗಳು, ನೀವು ಆಬ್ಜೆಕ್ಟ್ ಶಾಖೆಯನ್ನು ವಿಸ್ತರಿಸಬೇಕಾಗಿದೆ.

ನೀವು ಕೋಷ್ಟಕ ಭಾಗವನ್ನು ಆಯ್ಕೆ ಮಾಡಿದಾಗ, 1C ಸ್ವತಃ ಫಾರ್ಮ್‌ನಲ್ಲಿ ಟೇಬಲ್‌ಗೆ ಕಾಲಮ್‌ಗಳನ್ನು ಸೇರಿಸುತ್ತದೆ. ಅಂತಹ ಕೋಷ್ಟಕದಲ್ಲಿ ಬಳಕೆದಾರರು ನಮೂದಿಸಿದ ಸಾಲುಗಳನ್ನು ಉಲ್ಲೇಖ ಪುಸ್ತಕ/ಡಾಕ್ಯುಮೆಂಟ್ ಜೊತೆಗೆ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಉಳಿಸಲಾಗುತ್ತದೆ.

ಅದೇ ಡೇಟಾ ಆಸ್ತಿಯಲ್ಲಿ, ನೀವು ಅನಿಯಂತ್ರಿತ ಹೆಸರನ್ನು ನಮೂದಿಸಬಹುದು ಮತ್ತು ಮೌಲ್ಯ ಕೋಷ್ಟಕದ ಪ್ರಕಾರವನ್ನು ಆಯ್ಕೆ ಮಾಡಬಹುದು.

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

ಕ್ಲಿಕ್ ಮಾಡಲಾಗುತ್ತಿದೆ ಬಲ ಕ್ಲಿಕ್ಮೇಜಿನ ಮೇಲೆ ನೀವು ಕಾಲಮ್ ಅನ್ನು ಸೇರಿಸಬಹುದು. ಕಾಲಮ್‌ನ ಗುಣಲಕ್ಷಣಗಳಲ್ಲಿ, ನೀವು ಅದರ ಹೆಸರನ್ನು (1C ಕೋಡ್‌ನಲ್ಲಿ ಉಲ್ಲೇಖಕ್ಕಾಗಿ), ಫಾರ್ಮ್‌ನಲ್ಲಿನ ಕಾಲಮ್ ಶಿರೋನಾಮೆ, ಕೋಷ್ಟಕ ಭಾಗದ ಗುಣಲಕ್ಷಣದೊಂದಿಗೆ ಸಂಪರ್ಕವನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಬಹುದು (ಎರಡನೆಯದು - ಅನಿಯಂತ್ರಿತ ಕೋಷ್ಟಕವನ್ನು ಆಯ್ಕೆ ಮಾಡದಿದ್ದರೆ, ಆದರೆ a ಕೋಷ್ಟಕ ಭಾಗ).

ಫಾರ್ಮ್‌ನಲ್ಲಿರುವ ಟೇಬಲ್ ಗುಣಲಕ್ಷಣಗಳಲ್ಲಿ, ಬಳಕೆದಾರರು ಸಾಲುಗಳನ್ನು ಸೇರಿಸಬಹುದೇ/ಅಳಿಸಬಹುದೇ ಎಂದು ನೀವು ನಿರ್ದಿಷ್ಟಪಡಿಸಬಹುದು. ಹೆಚ್ಚು ಸುಧಾರಿತ ರೂಪವೆಂದರೆ ವೀಕ್ಷಣೆ ಮಾತ್ರ ಚೆಕ್‌ಬಾಕ್ಸ್. ಮಾಹಿತಿಯನ್ನು ಪ್ರದರ್ಶಿಸಲು ಉದ್ದೇಶಿಸಿರುವ ಕೋಷ್ಟಕಗಳನ್ನು ಸಂಘಟಿಸಲು ಈ ಗುಣಲಕ್ಷಣಗಳು ಬಳಸಲು ಅನುಕೂಲಕರವಾಗಿದೆ, ಆದರೆ ಸಂಪಾದನೆ ಅಲ್ಲ.

ಟೇಬಲ್ ಅನ್ನು ನಿರ್ವಹಿಸಲು, ನೀವು ಫಾರ್ಮ್ನಲ್ಲಿ ಕಮಾಂಡ್ ಪ್ಯಾನೆಲ್ ಅನ್ನು ಪ್ರದರ್ಶಿಸಬೇಕು. ಮೆನು ಐಟಂ ಫಾರ್ಮ್/ಇನ್ಸರ್ಟ್ ಕಂಟ್ರೋಲ್/ಕಮಾಂಡ್ ಬಾರ್ ಆಯ್ಕೆಮಾಡಿ.

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

ಫಾರ್ಮ್‌ನಲ್ಲಿ ಟೇಬಲ್ (ತೆಳುವಾದ/ನಿರ್ವಹಿಸಿದ ಕ್ಲೈಂಟ್)

ನಿರ್ವಹಿಸಿದ ರೂಪದಲ್ಲಿ, ಈ ಕ್ರಿಯೆಗಳು ಸ್ವಲ್ಪ ವಿಭಿನ್ನವಾಗಿ ಕಾಣುತ್ತವೆ. ನೀವು ಫಾರ್ಮ್‌ನಲ್ಲಿ ಕೋಷ್ಟಕ ಭಾಗವನ್ನು ಇರಿಸಬೇಕಾದರೆ, ಆಬ್ಜೆಕ್ಟ್ ಶಾಖೆಯನ್ನು ವಿಸ್ತರಿಸಿ ಮತ್ತು ಟೇಬಲ್ ಭಾಗಗಳಲ್ಲಿ ಒಂದನ್ನು ಎಡಕ್ಕೆ ಎಳೆಯಿರಿ. ಅಷ್ಟೇ!

ನೀವು ಮೌಲ್ಯಗಳ ಕೋಷ್ಟಕವನ್ನು ಇರಿಸಬೇಕಾದರೆ, ಹೊಸ ಫಾರ್ಮ್ ಗುಣಲಕ್ಷಣವನ್ನು ಸೇರಿಸಿ ಮತ್ತು ಅದರ ಗುಣಲಕ್ಷಣಗಳಲ್ಲಿ ಪ್ರಕಾರವನ್ನು ಸೂಚಿಸಿ - ಮೌಲ್ಯಗಳ ಕೋಷ್ಟಕ.

ಕಾಲಮ್‌ಗಳನ್ನು ಸೇರಿಸಲು, ಈ ಫಾರ್ಮ್ ಗುಣಲಕ್ಷಣದಲ್ಲಿ ಬಲ ಕ್ಲಿಕ್ ಮೆನು ಬಳಸಿ, ಗುಣಲಕ್ಷಣದ ಕಾಲಮ್ ಅನ್ನು ಸೇರಿಸಿ ಆಯ್ಕೆಮಾಡಿ.

ನಂತರ ಟೇಬಲ್ ಅನ್ನು ಎಡಕ್ಕೆ ಎಳೆಯಿರಿ.

ಟೇಬಲ್ ಕಮಾಂಡ್ ಬಾರ್ ಅನ್ನು ಹೊಂದಲು, ಟೇಬಲ್ ಗುಣಲಕ್ಷಣಗಳಲ್ಲಿ, ಬಳಕೆ - ಕಮಾಂಡ್ ಬಾರ್ ಸ್ಥಾನ ವಿಭಾಗದಲ್ಲಿ ಮೌಲ್ಯಗಳನ್ನು ಆಯ್ಕೆಮಾಡಿ.

ಎಕ್ಸೆಲ್‌ಗೆ ಟೇಬಲ್ ಅನ್ನು ಅಪ್‌ಲೋಡ್ ಮಾಡಲಾಗುತ್ತಿದೆ

ಫಾರ್ಮ್‌ನಲ್ಲಿರುವ ಯಾವುದೇ 1C ಟೇಬಲ್ ಅನ್ನು ಮುದ್ರಿಸಬಹುದು ಅಥವಾ ಎಕ್ಸೆಲ್‌ಗೆ ಅಪ್‌ಲೋಡ್ ಮಾಡಬಹುದು.

ಇದನ್ನು ಮಾಡಲು, ಬಲ ಕ್ಲಿಕ್ ಮಾಡಿ ಖಾಲಿ ಜಾಗಕೋಷ್ಟಕದಲ್ಲಿ ಮತ್ತು ಪಟ್ಟಿಯನ್ನು ಆಯ್ಕೆಮಾಡಿ.

ನಿರ್ವಹಿಸಲಾದ (ತೆಳುವಾದ) ಕ್ಲೈಂಟ್‌ನಲ್ಲಿ, ಮೆನು ಐಟಂ ಎಲ್ಲಾ ಕ್ರಿಯೆಗಳು/ಪ್ರದರ್ಶನ ಪಟ್ಟಿಯನ್ನು ಬಳಸಿಕೊಂಡು ಇದೇ ರೀತಿಯ ಕ್ರಿಯೆಗಳನ್ನು ಮಾಡಬಹುದು.