the problem for me is I don't understand what is happening
Hi
@Steve-h
please find below a step-by-step explanation of my code from post #7 above.
'Works for ints in the range 0-65535 (hex 0000-FFFF)
The comment specifies that the code works ok for the range indicated. If you try any valid integer outside that range (e.g. a negative or an higher positive) it will fail.
This is because the code is tailored to your use case "
My application requires a 4 digit hex value", so it expects values in that range
Private Sub intohex (intin As Int) As String
This is the sub signature. Private means that the sub is private to the hosting module containing it. Other modules won't see it.
Dim hexstr As String = Bit.ToHexString(intin)
This is a short form for two distinct instructions:
Dim hexstr as String 'declares and creates a string variable
hextsr = Bit.ToHextString(intin) ' calls function Bit.ToHextString passing it an integer and receiving back a string representing that int as an hex
Return "0000".SubString2(0,4-hexstr.Length)&hexstr.ToUpperCase
This is a very compact form for a few instructions
1.
"0000" is equivalent to
Dim temp as String
temp = "0000"
2.
SubString2(0,4-hexstr.Length)
Function SubString2 (applied to the preceding string) has the effect of extracting zero or more characters from the given string.
First parameters is the index of the first char to extract; second parameter is the index of the first char to ignore
Index count starts a zero (so the very first char in your string has index 0)
So, for example, "012345".SubString2(2,5) returns string "234" (without double-quotes)
3. Combining points 1 e 2 above we have
"0000".SubString2(0,4-hexstr.Length)
which means "
extract from string 0000 from zero to 4 chars depending on the length of string hexstr"
Now, from the initial comment, we know that hextstr length will be from 1 (for decimals 0 to 15) to 4 (from 4096 upwards)
So the final result is to retun as many 0s are needed in order to have a final string of 4 chars in all.
This explains why the code will fail for integers greater than 65535 or negative: they will produce an hex string longer than 4, so the second parameter wil be negative.
4.
&hexstr
& is the concatenation operator. So it produces a new string that is the concatenation of the one preceding it with the one following it
In our case is the concatenation of the right number of zeroes produced by SubString2 and the hex string as returned by Bit.ToHextString(intin)
This is already your expected final result. Strings like 000a, 001f.. are retruned at this step.
5.
ToUpperCase
This function converts to uppercase all the chars of the string it is applied to.
In our case, the string which chars are uppercased is
"0000".SubString2(0,4-hexstr.Length)&hexstr
This will turn 000a to 000A, 001f to 001F and son on.
6
Return
This one is the last instruction in your sub. It returns to the calling code the object following it.
In our case, since we defined the
Sub intohex as a "function" returning a string, it must return the string produced by the concatenation of actions performed from point 1 to point 5 above.
A final word.
In post #7 I highlighted that a benefit of this code is that it avoids the loop showed in post #3
Why it could be important (not necessarily in this context)?
Well, in Java (and so in B4X) strings are immutable objects. This means that when you modify a string behind the scene the JVM (Java Virtual machine) is allocating a new string on the heap with the new value (at least if that new value isn't already on the heap, but that's another story)
So the loop in post #3 causes the allocation of a new string for each 0 prefixed at each iteration
If your initial integer is 12 (hex C) the loop will produce the following strings
0C
00C
000C
then it will exit because it reached the 4 chars length is was looking for.
Note: don't be fooled by the concision of my code. Behind the scenes the JVM would certainly need to allocate temp strings so, in this case, the advantage could be simply apparent.