Introduction to Visual Basic Built-In Functions
Introduction
You may recall that when studying data types, we saw that each had a corresponding function used to convert a string value or an expression to that type. As a reminder, the general syntax of the conversion functions is:
ReturnType = FunctionName(Expression)
The Expression could be of any kind. For
example, it could be a string or expression that would produce a value
such as the result of a calculation. The conversion function would take
such a value, string, or expression and attempt to convert it. If the
conversion is successful, the function would return a new value that is of
the type specified by the ReturnType in our syntax.
The
conversion functions are as follows:
Function | ||
Name | Return Type | Description |
CBool | Boolean | Converts an expression into a Boolean value |
CByte | Byte | Converts an expression into Byte number |
CDbl | Double | Converts an expression into a floating-point number with double precision |
CDec | Decimal | Converts an expression into a decimal number |
CInt | Integer | Converts an expression into an integer (natural) number |
CLng | Long | Converts an expression into a long integer (a large natural) number |
CObj | Object | Converts an expression into an Object type |
CSByte | SByte | Converts an expression into a signed byte |
CShort | Short | Converts an expression into a short integer |
CSng | Single | Converts an expression into a floating-point number with single precision |
CUInt | UInt | Converts an expression into an unsigned integer |
CULng | ULong | Converts an expression into an unsigned long integer |
CUShort | UShort | Converts an expression into an unsigned short integer |
Type Conversion |
Conversion functions allow you to convert a known value to a another type. Besides these functions, the Visual Basic language provides a function named CType. Its syntax is:
CType(expression, typename)
As you can see, the CType() function takes two arguments. The first argument is the expression or the value that you want to convert. An example could be name of a variable or a calculation:
CType(250.48 * 14.05, ...)
The second argument is the type of value you want to convert the first argument to. From what have learned so far, this second argument can be one of the data types we reviewed in Lesson 3. Here is an example:
CType(250.48 * 14.05, Single)
If you choose one of the Visual Basic language's data types, the expression produced by the first argument must be able to produce a value that is conform to the type of the second argument:
- The conversion from the first argument to the type of the second argument must be possible: the value produced by the first must be convertible to the second arguments. For example, if the first argument is a calculation, the second argument must be a number-based data type. In the same way, you cannot convert a date to a number-based type
- If the first argument is a number or the result of a calculation,
its resulting value must be lower than or up to the range of values of
the second argument. Here is an example:
Public Module Exercise Public Function Main() As Integer MsgBox(CType(250.48 * 14.05, Single)) Return 0 End Function End Module
This would produce:
- If the first argument is a number or the result of a calculation
that produces an integer or a floating-point number, its resulting
value must be convertible to an integer or a floating point number up
to the range of values of the second argument. Here is an example:
Public Module Exercise Public Function Main() As Integer MsgBox(CType(7942.225 * 202.46, UInteger)) Return 0 End Function End Module
This would produce:
- If the first argument is a number or the result of a calculation
that produces an integer or a floating-point number, the second
argument is a number-based data type but whose range cannot hold the
resulting value of the first argument, the conversion would not be
allowed (the conversion will fail):
After the CType() function has performed its conversion, it returns a value that is the same category as the second argument. For example, you can call a CType() function that converts an expression to a long integer. Here is an example:
Public Module Exercise Public Function Main() As Integer Dim Number As Long Number = CType(7942.225 * 202.46, Long) Return 0 End Function End Module
The function can also return a different type, as long as its type can hold the value produced by the expression. Here are two examples:
Public Module Exercise Public Function Main() As Integer Dim Number As UInteger Number = CType(7942.225 * 202.46, Long) Return 0 End Function End Module
Or
Public Module Exercise Public Function Main() As Integer Dim Number As Single Number = CType(7942.225 * 202.46, Long) Return 0 End Function End Module
If you try storing the returned value into a variable that cannot hold it, you would receive an error:
Visual Basic Built-In Functions: Conversions
Introduction
You may recall that when studying data types, we saw that each had a corresponding function used to convert a string value or an expression to that type. As a reminder, the general syntax of the conversion functions is:
ReturnType = FunctionName(Expression)
The Expression could be of any kind. For
example, it could be a string or expression that would produce a value
such as the result of a calculation. The conversion function would take
such a value, string, or expression and attempt to convert it. If the
conversion is successful, the function would return a new value that is of
the type specified by the ReturnType in our syntax.
The
conversion functions are as follows:
Function | ||
Name | Return Type | Description |
CBool | Boolean | Converts an expression into a Boolean value |
CByte | Byte | Converts an expression into Byte number |
CDbl | Double | Converts an expression into a floating-point number with double precision |
CDec | Decimal | Converts an expression into a decimal number |
CInt | Integer | Converts an expression into an integer (natural) number |
CLng | Long | Converts an expression into a long integer (a large natural) number |
CObj | Object | Converts an expression into an Object type |
CSByte | SByte | Converts an expression into a signed byte |
CShort | Short | Converts an expression into a short integer |
CSng | Single | Converts an expression into a floating-point number with single precision |
CUInt | UInt | Converts an expression into an unsigned integer |
CULng | ULong | Converts an expression into an unsigned long integer |
CUShort | UShort | Converts an expression into an unsigned short integer |
Type Conversion |
Conversion functions allow you to convert a known value to a another type. Besides these functions, the Visual Basic language provides a function named CType. Its syntax is:
CType(expression, typename)
As you can see, the CType() function takes two arguments. The first argument is the expression or the value that you want to convert. An example could be name of a variable or a calculation:
CType(250.48 * 14.05, ...)
The second argument is the type of value you want to convert the first argument to. From what have learned so far, this second argument can be one of the data types we reviewed in Lesson 3. Here is an example:
CType(250.48 * 14.05, Single)
If you choose one of the Visual Basic language's data types, the expression produced by the first argument must be able to produce a value that is conform to the type of the second argument:
- The conversion from the first argument to the type of the second argument must be possible: the value produced by the first must be convertible to the second arguments. For example, if the first argument is a calculation, the second argument must be a number-based data type. In the same way, you cannot convert a date to a number-based type
- If the first argument is a number or the result of a calculation,
its resulting value must be lower than or up to the range of values of
the second argument. Here is an example:
Public Module Exercise Public Function Main() As Integer MsgBox(CType(250.48 * 14.05, Single)) Return 0 End Function End Module
This would produce:
- If the first argument is a number or the result of a calculation
that produces an integer or a floating-point number, its resulting
value must be convertible to an integer or a floating point number up
to the range of values of the second argument. Here is an example:
Public Module Exercise Public Function Main() As Integer MsgBox(CType(7942.225 * 202.46, UInteger)) Return 0 End Function End Module
This would produce:
- If the first argument is a number or the result of a calculation
that produces an integer or a floating-point number, the second
argument is a number-based data type but whose range cannot hold the
resulting value of the first argument, the conversion would not be
allowed (the conversion will fail):
After the CType() function has performed its conversion, it returns a value that is the same category as the second argument. For example, you can call a CType() function that converts an expression to a long integer. Here is an example:
Public Module Exercise Public Function Main() As Integer Dim Number As Long Number = CType(7942.225 * 202.46, Long) Return 0 End Function End Module
The function can also return a different type, as long as its type can hold the value produced by the expression. Here are two examples:
Public Module Exercise Public Function Main() As Integer Dim Number As UInteger Number = CType(7942.225 * 202.46, Long) Return 0 End Function End Module
Or
Public Module Exercise Public Function Main() As Integer Dim Number As Single Number = CType(7942.225 * 202.46, Long) Return 0 End Function End Module
If you try storing the returned value into a variable that cannot hold it, you would receive an error:
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: Introduction 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. 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.
You may recall that when studying data types, we saw that each had a corresponding function used to convert a string value or an expression to that type. As a reminder, the general syntax of the conversion functions is: ReturnType = FunctionName(Expression) The Expression could be of any kind. For example, it
could be a string or expression that would produce a value such as the result of a calculation. The conversion function would take such a value, string, or
expression and attempt to convert it. If the conversion is successful,
the function would return a new value that is of the type specified by
the ReturnType in our syntax.
These functions allow you to convert a known value to a another type. Besides these functions, the Visual Basic language provides a function named CType. Its syntax is: CType(expression, typename) As you can see, the CType() function takes two arguments. The first argument is the expression or the value that you want to convert. An example could be name of a variable or a calculation: CType(250.48 * 14.05, ...) The second argument is the type of value you want to convert the first argument to. From what have learned so far, this second argument can be one of the data types we reviewed in Lesson 3. Here is an example: CType(250.48 * 14.05, Single) If you choose one of the Visual Basic language's data types, the expression produced by the first argument must be able to produce a value that is conform to the type of the second argument:
|