Introduction to Visual Basic Built-In Functions
|
Introduction to Visual Basic Built-In Functions |
|
Overview of Built-In Procedures |
|
Introduction |
|
A procedure is referred to as "built-in" if it shipped with its programming language. To make your job a little easier, the Visual Basic language is equipped with many procedures that you can use right away in your program. Based on this, before creating your own procedure, first check whether the functionality you are looking for is already implementing in one of the available procedures because those that ship with the Visual Basic language are highly reliable and should be preferred. |
|
Before using a built-in procedure, you must of course be familiar with it. This comes either by consulting the documentation or by experience. This means that you must know its name, its argument(s), its return value, and its role. The Visual Basic programming language provides one of the richest libraries you will ever see. In fact, it is the richest of the .NET-based languages, giving you access to functions that are not directly available to other languages such as C# or C++/CLI. Because there so many of those functions, we will review only the most usually used. Eventually, when necessary, in other lessons, we may introduce new ones. |
If you have a decimal number but are interested only in the integral part, to assist you with retrieving that part, the Visual Basic language provides the Int() and the Fix() functions. Their syntaxes are: Public Shared Function Int( _
ByVal Number As { Double | Integer | Long |
Object | Short | Single | Decimal }) _
As { Double | Integer | Long | Object | Short | Single | Decimal }
Public Shared Function Fix( _
ByVal Number As { Double | Integer | Long |
Object | Short | Single | Decimal }) _
As { Double | Integer | Long | Object | Short | Single | Decimal }
Each function must take one argument. The value of the argument must be number-based. This means it can be an integer or a floating-point number. If the value of the argument is integer-based, the function returns the (whole) number. Here is an example Public Module Exercise
Public Function Main() As Integer
Dim Number As Integer
Number = 286345
MsgBox(Int(Number))
Return 0
End Function
End Module
This would produce:
If the value of the argument is a decimal number, the function returns only the integral part. Here is an example Public Module Exercise
Public Function Main() As Integer
Dim Number As UInteger
Number = 7942.225 * 202.46
MsgBox(Int(Number))
Return 0
End Function
End Module
This would produce:
This function always returns the integral part only, even if you ask it to return a floating-point-based value. Here is an example: Public Module Exercise
Public Function Main() As Integer
Dim Number As Single
Number = 286345.9924
MsgBox(Int(Number))
Return 0
End Function
End Module
This would produce:
A random number is a value that is not known in advanced until it is generated by the compiler. To assist you with getting a random number, the Visual Basic language provides a function named Rnd. Its syntax is: Public Shared Function Rnd[(Number)] As Single This function takes an optional argument. If the argument is not passed, the compiler would simply generate a positive decimal number between 0 and 1. Here is an example: Public Module Exercise
Public Function Main() As Integer
MsgBox("Random Number: " & Rnd())
Return 0
End Function
End Module
This would produce:
You may wonder how the compiler generates a random number. Without going into all the details, in most cases, a compiler refers to the system clock (the clock of the computer on which the application is). It uses a certain algorithm to get that number. If you call the function like we did above, every time you execute the application, you are likely to get the same result. Depending on how you want to use the number, in some cases, you may want to get a different number every time. To support this, random arithmetic supports what is referred to as a seed. If you do not use a seed, the compiler would keep the same number it generated from the system clock the first time it was asked to produce a random number. Seeding allows the compiler to reset this mechanism, which would result in a new random number. To assist you with seeding, the Visual Basic language provides a function named Randomize. Its syntax is: Public Shared Sub Randomize ([ Number ]) This function takes one optional argument. If you can this function without the argument, the compiler would refer to the system clock to generate the new random number. Of course, to get the number, you must call this function before calling Rnd(). Here is an example: Public Module Exercise
Public Function Main() As Integer
Randomize()
MsgBox("Random Number: " & Rnd())
Return 0
End Function
End Module
This time, every time the Rnd() function is called, the compiler generates a new number. Instead of letting the compiler refer to the system clock, you can provide your own seed value. To do this, pass a number to the Randomize() function. We mentioned that the Rnd() function generates a number between 0 and 1. Of course, in some cases you will want the number to be in a higher range, such as between 0 and 100 or between 0 and 100000. All you have to do is to multiply the result to a number of your choice. Here is an example: Public Module Exercise
Public Function Main() As Integer
Randomize()
MsgBox("Random Number: " & CStr(100 * Rnd()))
Return 0
End Function
End Module
This would produce:
Also notice that the result is a decimal number. If you interested in only the integral part of the number, you can call the Int() function.
So far, after performing a calculation, we were presenting the result "as is". To appropriately display a value, the Visual Basic language provides a function named Format. This function can be used for different types of values The most basic technique consists of passing it an expression that holds the value to display. The syntax of this function is: Public Shared Function Format( _ ByVal Expression As Object, _ Optional ByVal Style As String = "" _ ) As String As mentioned above, this function can be used in various scenarios. The simplest way to use this function is to pass it a number, a string, or a date/time). The function would then produce that number. Besides the Format() function, the Visual Basic language provides some additional functions we will review below.
So far, to display a number, we simply passed it to the MsgBox() function or to another procedure. In some cases, you may want the number to display in a particular format. To control how the number should display, you can pass the second argument of the Format() function. This argument would be passed as a string. To produce the number in a general format, you can pass the second argument as "g", "G", "f", or "F" . To display the number with a decimal separator, pass the second argument as "n", "N", or "Standard". Here is an example: Public Module Exercise
Public Function Main() As Integer
Dim Number As Double
Number = 20502.48
MsgBox("Number: " & Format(Number, "STANDARD"))
Return 0
End Function
End Module
This would produce:
An alternative to get this format is to call a function named FormatNumber. Its syntax is: Function FormatNumber( ByVal Expression As Object, Optional ByVal NumDigitsAfterDecimal As Integer = -1, Optional ByVal IncludeLeadingDigit As TriState = TriState.UseDefault, Optional ByVal UseParensForNegativeNumbers As TriState = TriState.UseDefault, Optional ByVal GroupDigits As TriState = TriState.UseDefault ) As String Only the first argument is required and it represents the value to display. If you pass only this argument, you get the same format as the Format() function called with the Standard option. Here is an example: Public Module Exercise
Public Function Main() As Integer
Dim Number As Double
Number = 20502.48
MsgBox("Number: " & Format(Number, "STANDARD"))
MsgBox("Number: " & FormatNumber(Number))
Return 0
End Function
End Module
This would produce the same result as above. If you call the Format() function with the Standard option, it would consider only the number of digits on the right side of the decimal separator. If you want to display more digits than the number actually has, call the FormatNumber() function and pass a second argument with the desired number. Here is an example: Public Module Exercise
Public Function Main() As Integer
Dim Number As Double
Number = 20502.48
MsgBox("Number: " & Format(Number, "STANDARD") & vbCrLf & _
"Number: " & FormatNumber(Number, 4))
Return 0
End Function
End Module
This would display:
In the same way, if you want the number to display with less numbers on the right side of the decimal separator, specify that number. As a third alternative, you can call the Format() function. In reality, the second argument is used to format the number with many more options. To represent the integral part of a number, you use the # sign. To specify the number of digits to display on the right side of the decimal separator, type a period on the right side of # followed by the number of 0s representing each decimal place. Here is an example: Public Module Exercise
Public Function Main() As Integer
Dim Number As Double
Number = 20502.48
MsgBox("Number: " & Format(Number, "#.00000"))
Return 0
End Function
End Module
The five 0s on the right side of the period indicate that you want to display 5 digits on the right side of the period. This would produce:
You can enter as many # signs as you want; it wouldn't change anything. Here is an example: Public Module Exercise
Public Function Main() As Integer
Dim Number As Double
Number = 20502.48
MsgBox("Number: " & Format(Number, "##########.00000"))
Return 0
End Function
End Module
This would produce the same result as above. To specify that you want to display the decimal separator, include its character between the # signs. Here is an example: Public Module Exercise
Public Function Main() As Integer
Dim Number As Double
Number = 20502.48
MsgBox("Number: " & Format(Number, "###,#######.00000"))
Return 0
End Function
End Module
This would produce:
You can include any other character or symbol you want in the string to be part of the result, but you should include such a character only at the beginning or the end of the string, otherwise the interpreter might give you an unexpected result.
Another regular type of number used in applications and finances is the currency. A currency value uses a special character specified in the Control Panel. In US English, this character would be the $ sign:
Of course, to display a symbol in the result, you can simply add it as part of the second argument to the Format() function. Here is an example: Public Module Exercise
Public Function Main() As Integer
Dim Number As Double
Number = 205.5
MsgBox("Number: " & Format(Number, "$###,#######.00"))
Return 0
End Function
End Module
This would produce:
Fortunately, there are more professional options. Besides the Format() function, to support currency formatting of a number, the Visual Basic language provides the FormatCurrency() function. Its syntax is: Function FormatCurrency( ByVal Expression As Object, Optional ByVal NumDigitsAfterDecimal As Integer = -1, Optional ByVal IncludeLeadingDigit As TriState = TriState.UseDefault, Optional ByVal UseParensForNegativeNumbers As TriState = TriState.UseDefault, Optional ByVal GroupDigits As TriState = TriState.UseDefault ) As String Only the first argument is required. It is the value that needs to be formatted. Here is an example: Public Module Exercise
Public Function Main() As Integer
Dim UnitPrice As Double
UnitPrice = 1450.5
MsgBox("Dress Price: " & FormatCurrency(UnitPrice))
Return 0
End Function
End Module
This would produce:
Notice that, by default, the FormatCurrency() function is equipped to display the currency symbol (which in US English is the $ sign), the decimal separator (which is US English is the comma), and two decimal digits. If you want to control how many decimal digits are given to the result, pass a second argument as an integer. Here is an example: Public Module Exercise
Public Function Main() As Integer
Dim UnitPrice As Double
UnitPrice = 1450.5
MsgBox("Dress Price: " & FormatCurrency(UnitPrice, 4))
Return 0
End Function
End Module
Instead of calling the FormatCurrency() function to format a number to currency, you can use the Format() function. If you do, pass it a second argument as "Currency", "c", or "C". Here is an example: Public Module Exercise
Public Function Main() As Integer
Dim CarPrice As Double
CarPrice = 42790
MsgBox("Car Price: " & Format(CarPrice, "Currency"))
Return 0
End Function
End Module
This would produce:
A percentage of a number represents its rate on a scale, usually of 100 (or more). The number is expressed using digits accompanied by the % sign. Besides the Format() function, to support percent values, the Visual Basic language provides a function named FormatPercent. Its syntax is: Function FormatPercent( ByVal Expression As Object, Optional ByVal NumDigitsAfterDecimal As Integer = -1, Optional ByVal IncludeLeadingDigit As TriState = TriState.UseDefault, Optional ByVal UseParensForNegativeNumbers As TriState = TriState.UseDefault, Optional ByVal GroupDigits As TriState = TriState.UseDefault ) As String Only the first argument is required and it is the number that needs to be formatted. When calling this function, pay attention to the number you provide as argument. If the number represents a percentage value as a fraction of 0 to 1, make sure you provide it as such. An example would be 0.25. In this case, the Visual Basic interpreter would multiply the value by 100 to give the result. Here is an example: Public Module Exercise
Public Function Main() As Integer
Dim DiscountRate As Double
DiscountRate = 0.25
MsgBox("Discount Rate: " & FormatPercent(DiscountRate))
Return 0
End Function
End Module
This would produce:
On the other hand, if you pass the value in the hundreds, the interpreter would still multiply it by 100. Although it is not impossible to get a percentage value in the hundreds or thousands, you should make sure that's the type of value you mean to get. Besides the FormatPercent() function, to format a number to its percentage equivalent, you can call the Format() function and pass the second argument as "Percent", "p", or "P". Here is an example: Public Module Exercise
Public Function Main() As Integer
Dim DiscountRate As Double
DiscountRate = 0.25
MsgBox("Discount Rate: " & Format(DiscountRate, "Percent"))
Return 0
End Function
End Module
|
|
|
||
| Previous | Copyright © 2008-2009 FunctionX | Next |
|
|
||
