खोज…
VBA में एक ऐरे की घोषणा
किसी ऐरे की घोषणा करना एक वैरिएबल को घोषित करने के समान है, इसके अलावा आपको ऐरे के आयाम को उसके नाम के ठीक बाद घोषित करने की आवश्यकता है:
Dim myArray(9) As String 'Declaring an array that will contain up to 10 strings
डिफ़ॉल्ट रूप से, VBA में Arrays को शून्य से अनुक्रमित किया जाता है , इस प्रकार, कोष्ठक के अंदर की संख्या सरणी के आकार को संदर्भित नहीं करती है, बल्कि अंतिम तत्व के सूचकांक को
एक्सेस करने वाले तत्व
एरे के एक तत्व तक पहुंचना एरे के नाम का उपयोग करके किया जाता है, इसके बाद तत्व के सूचकांक, कोष्ठक के अंदर:
myArray(0) = "first element"
myArray(5) = "sixth element"
myArray(9) = "last element"
ऐरे इंडेक्सिंग
आप मॉड्यूल के शीर्ष पर इस रेखा को रखकर Arrays अनुक्रमण को बदल सकते हैं:
Option Base 1
इस लाइन के साथ, मॉड्यूल में घोषित सभी एरर्स को वन से अनुक्रमित किया जाएगा।
विशिष्ट सूचकांक
आप प्रत्येक कीवर्ड To
अपने सूचकांक के साथ To
कीवर्ड और निम्न और ऊपरी बाउंड (= अनुक्रमणिका) का उपयोग करके घोषित कर सकते हैं:
Dim mySecondArray(1 To 12) As String 'Array of 12 strings indexed from 1 to 12
Dim myThirdArray(13 To 24) As String 'Array of 12 strings indexed from 13 to 24
गतिशील घोषणा
जब आप अपनी घोषणा से पहले अपने ऐरे के आकार को नहीं जानते हैं, तो आप डायनामिक घोषणा और ReDim
कीवर्ड का उपयोग कर सकते हैं:
Dim myDynamicArray() As Strings 'Creates an Array of an unknown number of strings
ReDim myDynamicArray(5) 'This resets the array to 6 elements
ध्यान दें कि ReDim
कीवर्ड का उपयोग करने से आपकी Array की कोई भी पिछली सामग्री समाप्त हो जाएगी। इसे रोकने के लिए, आप ReDim
बाद Preserve
कीवर्ड का उपयोग कर सकते हैं:
Dim myDynamicArray(5) As String
myDynamicArray(0) = "Something I want to keep"
ReDim Preserve myDynamicArray(8) 'Expand the size to up to 9 strings
Debug.Print myDynamicArray(0) ' still prints the element
एक स्ट्रिंग से एक सरणी बनाने के लिए स्प्लिट का उपयोग
स्प्लिट फंक्शन
एक शून्य-आधारित, एक आयामी सरणी देता है जिसमें निर्दिष्ट संख्या में सबस्ट्रिंग होते हैं।
वाक्य - विन्यास
विभाजन (अभिव्यक्ति [, सीमांकक [, सीमा [, तुलना ]]] )
अंश | विवरण |
---|---|
अभिव्यक्ति | आवश्यक है। स्ट्रिंग अभिव्यक्ति जिसमें सबस्ट्रिंग और सीमांकक होते हैं। यदि अभिव्यक्ति एक शून्य-लंबाई स्ट्रिंग ("" या vbNullString) है, तो स्प्लिट एक खाली सरणी देता है जिसमें कोई तत्व नहीं है और कोई डेटा नहीं है। इस स्थिति में, लौटे सरणी में 0 का LBound और -1 का UBound होगा। |
सीमांकक | वैकल्पिक। स्ट्रिंग कैरेक्टर सबस्ट्रिंग सीमाओं की पहचान करने के लिए उपयोग किया जाता है। यदि छोड़ा गया है, तो अंतरिक्ष वर्ण ("") को परिसीमनकर्ता माना जाता है। यदि सीमांकक एक शून्य-लंबाई वाला स्ट्रिंग है, तो एक एकल-तत्व सरणी जिसमें संपूर्ण अभिव्यक्ति स्ट्रिंग है वापस आ गया है। |
सीमा | वैकल्पिक। वापस करने के लिए सबस्ट्रिंग की संख्या; -1 इंगित करता है कि सभी सबस्ट्रिंग वापस आ गए हैं। |
तुलना | वैकल्पिक। न्यूमेरिक वैल्यू सब्सट्रेट का मूल्यांकन करते समय उपयोग की तुलना का संकेत देता है। मानों के लिए सेटिंग अनुभाग देखें। |
समायोजन
तुलना तर्क में निम्नलिखित मूल्य हो सकते हैं:
लगातार | मूल्य | विवरण |
---|---|---|
विवरण | -1 | विकल्प की तुलना कथन का उपयोग करके तुलना करता है। |
vbBinaryCompare | 0 | एक बाइनरी तुलना करता है। |
vbTextCompare | 1 | पाठ की तुलना करता है। |
vbDatabaseCompare | 2 | Microsoft केवल एक्सेस। आपके डेटाबेस में जानकारी के आधार पर तुलना करता है। |
उदाहरण
इस उदाहरण में यह दिखाया गया है कि कैसे कई शैलियों को दिखा कर स्प्लिट काम करता है। टिप्पणियां अलग-अलग प्रदर्शन किए गए स्प्लिट विकल्पों में से प्रत्येक के लिए निर्धारित परिणाम दिखाएंगी। अंत में यह दर्शाया गया है कि लौटे स्ट्रिंग ऐरे पर कैसे लूप करें।
Sub Test
Dim textArray() as String
textArray = Split("Tech on the Net")
'Result: {"Tech", "on", "the", "Net"}
textArray = Split("172.23.56.4", ".")
'Result: {"172", "23", "56", "4"}
textArray = Split("A;B;C;D", ";")
'Result: {"A", "B", "C", "D"}
textArray = Split("A;B;C;D", ";", 1)
'Result: {"A;B;C;D"}
textArray = Split("A;B;C;D", ";", 2)
'Result: {"A", "B;C;D"}
textArray = Split("A;B;C;D", ";", 3)
'Result: {"A", "B", "C;D"}
textArray = Split("A;B;C;D", ";", 4)
'Result: {"A", "B", "C", "D"}
'You can iterate over the created array
Dim counter As Long
For counter = LBound(textArray) To UBound(textArray)
Debug.Print textArray(counter)
Next
End Sub
एक सरणी के तत्वों को निष्क्रिय करना
अगले के लिए
सूचक संख्या के रूप में इट्रेटर चर का उपयोग करना किसी सरणी के तत्वों को पुनरावृत्त करने का सबसे तेज़ तरीका है:
Dim items As Variant
items = Array(0, 1, 2, 3)
Dim index As Integer
For index = LBound(items) To UBound(items)
'assumes value can be implicitly converted to a String:
Debug.Print items(index)
Next
नेस्टेड छोरों का उपयोग बहु-आयामी सरणियों को पुनरावृत्त करने के लिए किया जा सकता है:
Dim items(0 To 1, 0 To 1) As Integer
items(0, 0) = 0
items(0, 1) = 1
items(1, 0) = 2
items(1, 1) = 3
Dim outer As Integer
Dim inner As Integer
For outer = LBound(items, 1) To UBound(items, 1)
For inner = LBound(items, 2) To UBound(items, 2)
'assumes value can be implicitly converted to a String:
Debug.Print items(outer, inner)
Next
Next
प्रत्येक के लिए ... अगला
For Each...Next
लूप भी एटरेट सरणियों के लिए इस्तेमाल किया जा सकता है, अगर प्रदर्शन कोई फर्क नहीं पड़ता:
Dim items As Variant
items = Array(0, 1, 2, 3)
Dim item As Variant 'must be variant
For Each item In items
'assumes value can be implicitly converted to a String:
Debug.Print item
Next
For Each
लूप के For Each
बाहरी से आंतरिक तक सभी आयामों को पुनरावृत्त करेगा (उसी क्रम के रूप में तत्वों को स्मृति में रखा गया है), इसलिए नेस्टेड छोरों की कोई आवश्यकता नहीं है:
Dim items(0 To 1, 0 To 1) As Integer
items(0, 0) = 0
items(1, 0) = 1
items(0, 1) = 2
items(1, 1) = 3
Dim item As Variant 'must be Variant
For Each item In items
'assumes value can be implicitly converted to a String:
Debug.Print item
Next
ध्यान दें कि यदि प्रदर्शन मायने रखता है, तो For Each
लूप के लिए Collection
ऑब्जेक्ट्स को पुन: व्यवस्थित करने के लिए उपयोग किया जाता है।
उपरोक्त सभी 4 स्निपेट एक ही आउटपुट का उत्पादन करते हैं:
0
1
2
3
डायनामिक एरेज़ (सरणी का आकार बदलना और डायनेमिक हैंडलिंग)
डायनेमिक एरे
किसी सरणी पर वैरिएबल को जोड़ना और कम करना उस समय के लिए एक बहुत बड़ा लाभ होता है जब आप जिस सूचना का उपचार कर रहे होते हैं, उसमें वैरिएबल की एक निर्धारित संख्या नहीं होती है।
वैधानिक रूप से मूल्यों को जोड़ना
आप केवल ReDim
स्टेटमेंट के साथ ऐरे का आकार बदल सकते हैं, यह सरणी का आकार बदल देगा, लेकिन यदि आप जो पहले से संग्रहीत जानकारी को बनाए रखना चाहते हैं, तो आपको उस भाग को Preserve
करने की आवश्यकता होगी।
नीचे दिए गए उदाहरण में हम एक सरणी बनाते हैं और इसे पहले से ही सरणी में मानों को संरक्षित करते हुए प्रत्येक पुनरावृत्ति में एक और चर द्वारा बढ़ाते हैं।
Dim Dynamic_array As Variant
' first we set Dynamic_array as variant
For n = 1 To 100
If IsEmpty(Dynamic_array) Then
'isempty() will check if we need to add the first value to the array or subsequent ones
ReDim Dynamic_array(0)
'ReDim Dynamic_array(0) will resize the array to one variable only
Dynamic_array(0) = n
Else
ReDim Preserve Dynamic_array(0 To UBound(Dynamic_array) + 1)
'in the line above we resize the array from variable 0 to the UBound() = last variable, plus one effectivelly increeasing the size of the array by one
Dynamic_array(UBound(Dynamic_array)) = n
'attribute a value to the last variable of Dynamic_array
End If
Next
वैधानिक रूप से मूल्यों को हटाना
हम सरणी को कम करने के लिए उसी तर्क का उपयोग कर सकते हैं। उदाहरण में "अंतिम" मान को सरणी से हटा दिया जाएगा।
Dim Dynamic_array As Variant
Dynamic_array = Array("first", "middle", "last")
ReDim Preserve Dynamic_array(0 To UBound(Dynamic_array) - 1)
' Resize Preserve while dropping the last value
एक सरणी को रीसेट करना और गतिशील रूप से पुन: उपयोग करना
हम उन एरेज़ का फिर से उपयोग कर सकते हैं जो हम बनाते हैं ताकि मेमोरी पर बहुत सारे न हों, जो रन टाइम को धीमा कर देगा। यह विभिन्न आकारों के सरणियों के लिए उपयोगी है। एक स्निपेट को करने के लिए इस्तेमाल कर सकते हैं फिर से उपयोग सरणी है ReDim
सरणी के लिए वापस (0)
, विशेषता एक चर सरणी के लिए करने के लिए और स्वतंत्र रूप से सरणी फिर से वृद्धि हुई है।
नीचे दिए गए स्निपेट में मैं 1 से 40 मानों के साथ एक सरणी का निर्माण करता हूं, सरणी खाली करता हूं, और सरणी को 40 से 100 मानों के साथ फिर से भरता हूं, यह सब गतिशील रूप से किया गया है।
Dim Dynamic_array As Variant
For n = 1 To 100
If IsEmpty(Dynamic_array) Then
ReDim Dynamic_array(0)
Dynamic_array(0) = n
ElseIf Dynamic_array(0) = "" Then
'if first variant is empty ( = "") then give it the value of n
Dynamic_array(0) = n
Else
ReDim Preserve Dynamic_array(0 To UBound(Dynamic_array) + 1)
Dynamic_array(UBound(Dynamic_array)) = n
End If
If n = 40 Then
ReDim Dynamic_array(0)
'Resizing the array back to one variable without Preserving,
'leaving the first value of the array empty
End If
Next
दांतेदार Arrays (Arrays का तीर)
दांतेदार Arrays नहीं बहुआयामी Arrays
Arrays के Arrays (दांतेदार Arrays) बहुआयामी Arrays के समान नहीं हैं, यदि आप उनके बारे में सोचते हैं कि नेत्रहीन बहुआयामी Arrays अपने आयामों (सरणियों के अंदर) में परिभाषित तत्वों के साथ Matrices (आयताकार) की तरह दिखेंगे, जबकि दांतेदार सरणी एक वार्षिक वर्ष की तरह होगा। अंदर के सरणियों के साथ कैलेंडर में विभिन्न तत्वों की संख्या होती है, जैसे अलग-अलग महीनों में दिन।
हालांकि दांतेदार Arrays अपने नेस्टेड स्तरों के कारण उपयोग करने के लिए काफी गन्दा और मुश्किल है और इसमें बहुत प्रकार की सुरक्षा नहीं है, लेकिन वे बहुत लचीले हैं, आपको विभिन्न प्रकार के डेटा को आसानी से हेरफेर करने की अनुमति देते हैं, और अप्रयुक्त होने की आवश्यकता नहीं है या खाली तत्व।
एक दांतेदार ऐरे बनाना
नीचे दिए गए उदाहरण में हम एक दांतेदार सरणी को आरम्भ करेंगे, जिसमें दो सरणियों में से एक नाम और दूसरे के लिए संख्याएँ होंगी, और फिर प्रत्येक के प्रत्येक तत्व तक पहुँच होगी।
Dim OuterArray() As Variant
Dim Names() As Variant
Dim Numbers() As Variant
'arrays are declared variant so we can access attribute any data type to its elements
Names = Array("Person1", "Person2", "Person3")
Numbers = Array("001", "002", "003")
OuterArray = Array(Names, Numbers)
'Directly giving OuterArray an array containing both Names and Numbers arrays inside
Debug.Print OuterArray(0)(1)
Debug.Print OuterArray(1)(1)
'accessing elements inside the jagged by giving the coordenades of the element
डायनेमिक रूप से जगमगाती किरणों को बनाना और पढ़ना
हम सरणियों के निर्माण के लिए हमारी लगभग अधिक गतिशील हो सकते हैं, कल्पना करें कि हमारे पास एक्सेल में ग्राहक डेटा शीट है और हम ग्राहक विवरणों को आउटपुट करने के लिए एक सरणी का निर्माण करना चाहते हैं।
Name - Phone - Email - Customer Number
Person1 - 153486231 - 1@STACK - 001
Person2 - 153486242 - 2@STACK - 002
Person3 - 153486253 - 3@STACK - 003
Person4 - 153486264 - 4@STACK - 004
Person5 - 153486275 - 5@STACK - 005
हम गतिशील रूप से एक हेडर सरणी और एक ग्राहक सरणी का निर्माण करेंगे, हेडर में कॉलम शीर्षक होंगे और ग्राहक सरणी में प्रत्येक ग्राहक / पंक्ति की जानकारी एरे के रूप में होगी।
Dim Headers As Variant
' headers array with the top section of the customer data sheet
For c = 1 To 4
If IsEmpty(Headers) Then
ReDim Headers(0)
Headers(0) = Cells(1, c).Value
Else
ReDim Preserve Headers(0 To UBound(Headers) + 1)
Headers(UBound(Headers)) = Cells(1, c).Value
End If
Next
Dim Customers As Variant
'Customers array will contain arrays of customer values
Dim Customer_Values As Variant
'Customer_Values will be an array of the customer in its elements (Name-Phone-Email-CustNum)
For r = 2 To 6
'iterate through the customers/rows
For c = 1 To 4
'iterate through the values/columns
'build array containing customer values
If IsEmpty(Customer_Values) Then
ReDim Customer_Values(0)
Customer_Values(0) = Cells(r, c).Value
ElseIf Customer_Values(0) = "" Then
Customer_Values(0) = Cells(r, c).Value
Else
ReDim Preserve Customer_Values(0 To UBound(Customer_Values) + 1)
Customer_Values(UBound(Customer_Values)) = Cells(r, c).Value
End If
Next
'add customer_values array to Customers Array
If IsEmpty(Customers) Then
ReDim Customers(0)
Customers(0) = Customer_Values
Else
ReDim Preserve Customers(0 To UBound(Customers) + 1)
Customers(UBound(Customers)) = Customer_Values
End If
'reset Custumer_Values to rebuild a new array if needed
ReDim Customer_Values(0)
Next
Dim Main_Array(0 To 1) As Variant
'main array will contain both the Headers and Customers
Main_Array(0) = Headers
Main_Array(1) = Customers
To better understand the way to Dynamically construct a one dimensional array please check Dynamic Arrays (Array Resizing and Dynamic Handling) on the Arrays documentation.
उपरोक्त स्निपेट का परिणाम 4 तत्वों, 2 इंडक्शन स्तरों के साथ उन सरणियों में से दो सरणियों के साथ एक दांतेदार ऐरे है, और दूसरा स्वयं एक अन्य दांतेदार एरे है जिसमें 4 तत्वों में से 5 सरणियाँ हैं और 3 इंडक्शन स्तर हैं, संरचना के नीचे देखें:
Main_Array(0) - Headers - Array("Name","Phone","Email","Customer Number")
(1) - Customers(0) - Array("Person1",153486231,"1@STACK",001)
Customers(1) - Array("Person2",153486242,"2@STACK",002)
...
Customers(4) - Array("Person5",153486275,"5@STACK",005)
आपके द्वारा बनाई गई दांतेदार ऐरे की संरचना को ध्यान में रखते हुए जानकारी तक पहुंचने के लिए, ऊपर दिए गए उदाहरण में आप देख सकते हैं कि Main Array
में Headers
का एक एरे और एरे ( Customers
) का एक एरे होता है, इसलिए विभिन्न तरीकों से तत्वों तक पहुँचना।
अब हम Main Array
की जानकारी पढ़ेंगे और ग्राहकों की प्रत्येक जानकारी को Info Type: Info
रूप में प्रिंट करेंगे।
For n = 0 To UBound(Main_Array(1))
'n to iterate from fisrt to last array in Main_Array(1)
For j = 0 To UBound(Main_Array(1)(n))
'j will iterate from first to last element in each array of Main_Array(1)
Debug.Print Main_Array(0)(j) & ": " & Main_Array(1)(n)(j)
'print Main_Array(0)(j) which is the header and Main_Array(0)(n)(j) which is the element in the customer array
'we can call the header with j as the header array has the same structure as the customer array
Next
Next
अपने दांतेदार एरे की संरचना पर नज़र रखने के लिए याद रखें, उदाहरण के लिए ऊपर एक ग्राहक के नाम का उपयोग करने के लिए है Main_Array -> Customers -> CustomerNumber -> Name
जो तीन स्तरों पर "Person4"
, "Person4"
को वापस करने के लिए आपको आवश्यकता होगी Main_Array में ग्राहकों का स्थान, फिर ग्राहक के स्थान पर ग्राहक की चार भुजाएँ ऐरजेड और अंत में आपको जिस तत्व की आवश्यकता है, उसके स्थान पर, इस मामले में Main_Array(1)(3)(0)
जो Main_Array(Customers)(CustomerNumber)(Name)
।
बहुआयामी Arrays
बहुआयामी Arrays
जैसा कि नाम से संकेत मिलता है, बहुआयामी सरणियाँ ऐसे सरणियाँ हैं जिनमें एक से अधिक आयाम होते हैं, आमतौर पर दो या तीन लेकिन इसमें 32 आयाम हो सकते हैं।
एक बहु सरणी विभिन्न स्तरों के साथ एक मैट्रिक्स की तरह काम करती है, उदाहरण के लिए एक, दो और तीन आयामों के बीच तुलना करें।
एक आयाम आपका विशिष्ट सरणी है, यह तत्वों की सूची की तरह दिखता है।
Dim 1D(3) as Variant
*1D - Visually*
(0)
(1)
(2)
दो आयाम सुडोकू ग्रिड या एक एक्सेल शीट की तरह दिखते हैं, जब आप सरणी को आरंभीकृत करते हैं तो आप परिभाषित करेंगे कि सरणी में कितनी पंक्तियाँ और स्तंभ होंगे।
Dim 2D(3,3) as Variant
'this would result in a 3x3 grid
*2D - Visually*
(0,0) (0,1) (0,2)
(1,0) (1,1) (1,2)
(2,0) (2,1) (2,2)
तीन आयाम रुबिक के क्यूब की तरह दिखाई देने लगेंगे, जब आप सरणी को आरंम्भ करते हैं तो आप पंक्तियों और स्तंभों और परतों को परिभाषित करेंगे / सरणी की गहराई होगी।
Dim 3D(3,3,2) as Variant
'this would result in a 3x3x3 grid
*3D - Visually*
1st layer 2nd layer 3rd layer
front middle back
(0,0,0) (0,0,1) (0,0,2) ¦ (1,0,0) (1,0,1) (1,0,2) ¦ (2,0,0) (2,0,1) (2,0,2)
(0,1,0) (0,1,1) (0,1,2) ¦ (1,1,0) (1,1,1) (1,1,2) ¦ (2,1,0) (2,1,1) (2,1,2)
(0,2,0) (0,2,1) (0,2,2) ¦ (1,2,0) (1,2,1) (1,2,2) ¦ (2,2,0) (2,2,1) (2,2,2)
3 डी के गुणन के रूप में आगे के आयामों के बारे में सोचा जा सकता है, इसलिए एक 4D (1,3,3,3) दो-तरफा 3 डी सरणियां होंगी।
दो-आयाम अर्रे
बनाना
नीचे दिए गए उदाहरण में कर्मचारियों की एक सूची का संकलन होगा, प्रत्येक कर्मचारी के पास सूची पर जानकारी का एक सेट होगा (पहला नाम, उपनाम, पता, ईमेल, फोन ...), उदाहरण अनिवार्य रूप से सरणी पर संग्रहीत किया जाएगा ( कर्मचारी, सूचना) (0,0) कर्मचारी का पहला नाम है।
Dim Bosses As Variant
'set bosses as Variant, so we can input any data type we want
Bosses = [{"Jonh","Snow","President";"Ygritte","Wild","Vice-President"}]
'initialise a 2D array directly by filling it with information, the redult wil be a array(1,2) size 2x3 = 6 elements
Dim Employees As Variant
'initialize your Employees array as variant
'initialize and ReDim the Employee array so it is a dynamic array instead of a static one, hence treated differently by the VBA Compiler
ReDim Employees(100, 5)
'declaring an 2D array that can store 100 employees with 6 elements of information each, but starts empty
'the array size is 101 x 6 and contains 606 elements
For employee = 0 To UBound(Employees, 1)
'for each employee/row in the array, UBound for 2D arrays, which will get the last element on the array
'needs two parameters 1st the array you which to check and 2nd the dimension, in this case 1 = employee and 2 = information
For information_e = 0 To UBound(Employees, 2)
'for each information element/column in the array
Employees(employee, information_e) = InformationNeeded ' InformationNeeded would be the data to fill the array
'iterating the full array will allow for direct attribution of information into the element coordinates
Next
Next
पुन: आकार देने
आकार बदलने या ReDim Preserve
- ReDim Preserve
एक मल्टी-डायमेंशन को ReDim Preserve
करता है जैसे कि वन-डायमेंशन एरे के लिए मानदंड में त्रुटि हो जाती है, इसके बजाय सूचना को टेम्पररी एरे में उसी आकार में ट्रांसफर करना होता है, जिस तरह से मूल प्लस को जोड़ने के लिए पंक्ति / कॉलम की संख्या होती है। नीचे दिए गए उदाहरण में हम देखेंगे कि टेंप ऐरे को कैसे इनिशियलाइज़ किया जाए, ऑरिजिनल एरे से जानकारी ट्रांसफर की जाए, बाकी खाली एलिमेंट्स भरें और ऑरिजिनल एरे से टेम्प् आरेंज को बदलें।
Dim TempEmp As Variant
'initialise your temp array as variant
ReDim TempEmp(UBound(Employees, 1) + 1, UBound(Employees, 2))
'ReDim/Resize Temp array as a 2D array with size UBound(Employees)+1 = (last element in Employees 1st dimension) + 1,
'the 2nd dimension remains the same as the original array. we effectively add 1 row in the Employee array
'transfer
For emp = LBound(Employees, 1) To UBound(Employees, 1)
For info = LBound(Employees, 2) To UBound(Employees, 2)
'to transfer Employees into TempEmp we iterate both arrays and fill TempEmp with the corresponding element value in Employees
TempEmp(emp, info) = Employees(emp, info)
Next
Next
'fill remaining
'after the transfers the Temp array still has unused elements at the end, being that it was increased
'to fill the remaining elements iterate from the last "row" with values to the last row in the array
'in this case the last row in Temp will be the size of the Employees array rows + 1, as the last row of Employees array is already filled in the TempArray
For emp = UBound(Employees, 1) + 1 To UBound(TempEmp, 1)
For info = LBound(TempEmp, 2) To UBound(TempEmp, 2)
TempEmp(emp, info) = InformationNeeded & "NewRow"
Next
Next
'erase Employees, attribute Temp array to Employees and erase Temp array
Erase Employees
Employees = TempEmp
Erase TempEmp
तत्व मान बदलना
एक निश्चित तत्व में मूल्यों को बदलने / बदलने के लिए केवल समन्वय को बदलने और इसे एक नया मूल्य देने के लिए किया जा सकता है: Employees(0, 0) = "NewValue"
निर्देशांक के माध्यम से वैकल्पिक रूप से पुनरावृति आवश्यक शर्तों के अनुरूप मूल्यों से मेल खाने के लिए शर्तों का उपयोग करते हैं:
For emp = 0 To UBound(Employees)
If Employees(emp, 0) = "Gloria" And Employees(emp, 1) = "Stephan" Then
'if value found
Employees(emp, 1) = "Married, Last Name Change"
Exit For
'don't iterate through a full array unless necessary
End If
Next
पढ़ना
एरे में तत्वों को एक्सेस करना नेस्टेड लूप (हर एलिमेंट को इटर्नेट करते हुए), लूप और कोऑर्डिनेट (आईटीआर रोएं और सीधे कॉलम एक्सेस करना) के साथ किया जा सकता है, या सीधे दोनों निर्देशांक के साथ एक्सेस किया जा सकता है।
'nested loop, will iterate through all elements
For emp = LBound(Employees, 1) To UBound(Employees, 1)
For info = LBound(Employees, 2) To UBound(Employees, 2)
Debug.Print Employees(emp, info)
Next
Next
'loop and coordinate, iteration through all rows and in each row accessing all columns directly
For emp = LBound(Employees, 1) To UBound(Employees, 1)
Debug.Print Employees(emp, 0)
Debug.Print Employees(emp, 1)
Debug.Print Employees(emp, 2)
Debug.Print Employees(emp, 3)
Debug.Print Employees(emp, 4)
Debug.Print Employees(emp, 5)
Next
'directly accessing element with coordinates
Debug.Print Employees(5, 5)
याद रखें , बहु-आयामी सरणियों का उपयोग करते समय एक सरणी मानचित्र रखना हमेशा आसान होता है, वे आसानी से भ्रम बन सकते हैं।
तीन-आयाम अर्रे
3 डी सरणी के लिए, हम 2 डी सरणी के रूप में एक ही आधार का उपयोग करेंगे, न केवल कर्मचारी और सूचना के भंडारण के अलावा, बल्कि साथ ही साथ वे जिस भवन में काम करते हैं।
3D सरणी में कर्मचारी होंगे (पंक्तियों के रूप में सोचा जा सकता है), सूचना (कॉलम), और भवन जो किसी एक्सेल दस्तावेज़ पर अलग-अलग शीट के रूप में सोचा जा सकता है, उनके बीच एक ही आकार है, लेकिन हर शीट में एक है इसकी कोशिकाओं / तत्वों में जानकारी का अलग सेट। 3 डी सरणी शामिल n 2 डी सरणियों की संख्या होगी।
बनाना
एक 3 डी सरणी को 3 डी निर्देशांक की आवश्यकता होती है जिसे आरंभिक Dim 3Darray(2,5,5) As Variant
जाना चाहिए Dim 3Darray(2,5,5) As Variant
पर पहला समन्वय भवन / शीट्स (पंक्तियों और स्तंभों के अलग-अलग सेट) की संख्या होगी, दूसरा समन्वय पंक्तियों और तीसरे को परिभाषित करेगा। कॉलम। उपरोक्त Dim
का परिणाम 3 डी सरणी में 108 तत्वों ( 3*6*6
) के साथ होगा, प्रभावी रूप से 2 डी सरणियों के 3 अलग सेट होंगे।
Dim ThreeDArray As Variant
'initialise your ThreeDArray array as variant
ReDim ThreeDArray(1, 50, 5)
'declaring an 3D array that can store two sets of 51 employees with 6 elements of information each, but starts empty
'the array size is 2 x 51 x 6 and contains 612 elements
For building = 0 To UBound(ThreeDArray, 1)
'for each building/set in the array
For employee = 0 To UBound(ThreeDArray, 2)
'for each employee/row in the array
For information_e = 0 To UBound(ThreeDArray, 3)
'for each information element/column in the array
ThreeDArray(building, employee, information_e) = InformationNeeded ' InformationNeeded would be the data to fill the array
'iterating the full array will allow for direct attribution of information into the element coordinates
Next
Next
Next
पुन: आकार देने
3D सरणी का आकार बदलना, 2D को आकार देने के समान है, पहले पैरामीटर के समन्वय में एक को जोड़ने के लिए मूल के समान आकार के साथ एक अस्थायी सरणी बनाएं, पहला समन्वय सरणी में सेट की संख्या बढ़ाएगा, दूसरा और तीसरे निर्देशांक प्रत्येक सेट में पंक्तियों या स्तंभों की संख्या में वृद्धि करेंगे।
नीचे दिए गए उदाहरण से प्रत्येक सेट में पंक्तियों की संख्या बढ़ जाती है, और नई जानकारी के साथ हाल ही में जोड़े गए तत्वों को भरता है।
Dim TempEmp As Variant
'initialise your temp array as variant
ReDim TempEmp(UBound(ThreeDArray, 1), UBound(ThreeDArray, 2) + 1, UBound(ThreeDArray, 3))
'ReDim/Resize Temp array as a 3D array with size UBound(ThreeDArray)+1 = (last element in Employees 2nd dimension) + 1,
'the other dimension remains the same as the original array. we effectively add 1 row in the for each set of the 3D array
'transfer
For building = LBound(ThreeDArray, 1) To UBound(ThreeDArray, 1)
For emp = LBound(ThreeDArray, 2) To UBound(ThreeDArray, 2)
For info = LBound(ThreeDArray, 3) To UBound(ThreeDArray, 3)
'to transfer ThreeDArray into TempEmp by iterating all sets in the 3D array and fill TempEmp with the corresponding element value in each set of each row
TempEmp(building, emp, info) = ThreeDArray(building, emp, info)
Next
Next
Next
'fill remaining
'to fill the remaining elements we need to iterate from the last "row" with values to the last row in the array in each set, remember that the first empty element is the original array Ubound() plus 1
For building = LBound(TempEmp, 1) To UBound(TempEmp, 1)
For emp = UBound(ThreeDArray, 2) + 1 To UBound(TempEmp, 2)
For info = LBound(TempEmp, 3) To UBound(TempEmp, 3)
TempEmp(building, emp, info) = InformationNeeded & "NewRow"
Next
Next
Next
'erase Employees, attribute Temp array to Employees and erase Temp array
Erase ThreeDArray
ThreeDArray = TempEmp
Erase TempEmp
एलिमेंट वैल्यू और रीडिंग बदलना
3D सरणी पर तत्वों को पढ़ना और बदलना उसी तरह से किया जा सकता है जिस तरह से हम 2D सरणी करते हैं, बस छोरों और निर्देशांक में अतिरिक्त स्तर के लिए समायोजित करें।
Do
' using Do ... While for early exit
For building = 0 To UBound(ThreeDArray, 1)
For emp = 0 To UBound(ThreeDArray, 2)
If ThreeDArray(building, emp, 0) = "Gloria" And ThreeDArray(building, emp, 1) = "Stephan" Then
'if value found
ThreeDArray(building, emp, 1) = "Married, Last Name Change"
Exit Do
'don't iterate through all the array unless necessary
End If
Next
Next
Loop While False
'nested loop, will iterate through all elements
For building = LBound(ThreeDArray, 1) To UBound(ThreeDArray, 1)
For emp = LBound(ThreeDArray, 2) To UBound(ThreeDArray, 2)
For info = LBound(ThreeDArray, 3) To UBound(ThreeDArray, 3)
Debug.Print ThreeDArray(building, emp, info)
Next
Next
Next
'loop and coordinate, will iterate through all set of rows and ask for the row plus the value we choose for the columns
For building = LBound(ThreeDArray, 1) To UBound(ThreeDArray, 1)
For emp = LBound(ThreeDArray, 2) To UBound(ThreeDArray, 2)
Debug.Print ThreeDArray(building, emp, 0)
Debug.Print ThreeDArray(building, emp, 1)
Debug.Print ThreeDArray(building, emp, 2)
Debug.Print ThreeDArray(building, emp, 3)
Debug.Print ThreeDArray(building, emp, 4)
Debug.Print ThreeDArray(building, emp, 5)
Next
Next
'directly accessing element with coordinates
Debug.Print Employees(0, 5, 5)