If you want to build a house, you'll probably buy prefabricated windows and pre-hung doors instead of framing and hanging them yourself. Unless you want to spend extra time doing the work that you don't have to do, using the prefabricated windows and pre-hung doors makes quick work of those housing elements and allows you to concentrate your energies on the more esthetic items (such as talking your spouse into allowing you to partition two-thirds of the master bedroom for a great computer work area).
Visual Basic's built-in functions save you all kinds of programming time just as the pre-built housing parts do when home building. The built-in functions work like miniature programs that perform common tasks so that you can concentrate your efforts elsewhere. If, for instance, you need to round a single-precision value to an integer, Visual Basic supplies not one but three built-in functions that round numbers to integer values.
Tip: You've already seen several built-in functions in this book, such as Val() and Chr$(). Usually, though not always, a function that contains a dollar sign after its name is a string function, and a function without a dollar sign in its name is a numeric function. This unit teaches you about both numeric and string functions.
Concept: Functions accept one or more arguments and do work with those arguments. The function then returns a single value.
When you use a function inside a Visual Basic statement, it is said that you're calling a function. For example, the following statement calls the Val() function:
Num = Val(txtAmt.Text) ' Convert entry to number
Definition—An argument is a value that you pass to a function.
The parentheses after a function name hold one or more arguments. In the preceding statement, txtAmt.Text is the argument. Some functions, such as Val(), accept only one argument. Some functions accept more than one argument. Some functions don't require any arguments, and for those functions, the parentheses are optional. The arguments inside the parentheses are often called the argument list. A function can require none, one, or several arguments.
When you specify function arguments, you are passing the arguments to the function. The function works on the argument values that you pass to the function and produces some sort of value from the arguments. As Figure 13.1 illustrates, you send a function one or more arguments and the function, after using the arguments in the argument list, is said to return a value. That value is the answer to the function, more commonly called the return value. Functions are said to receive arguments and return a value.
Figure 13.1. A function works on its arguments and returns one value.
Note: It's worth making this very clear: A function always returns a single value and never more. Although a function's argument list can sometimes contain five or more arguments, a function never returns more than one value.
If a function requires more than one argument, you'll separate those arguments by one or more commas. For example, here is a function named Right$() that requires two arguments, MyName and 10, in its argument list:
Last = Right$(MyName, 10) ' Strip off last name
You'll always have to do something with a function's return value. Here are some things that you might do with a return value:
Basically, anything that you might do with a variable or a constant, you'll do with a function's return value. For example, you learned in Unit 7 how Val() works. Val() converts its string (or variant) argument to a number. The converted number is Val()'s return value. Val() will convert its argument to a single, return value; therefore, you can't place Val() on a line by itself like this:
Val(UserAddress) ' Invalid!
Val() will accept the string named UserAddress and convert that string to a number. You must make sure that the program does something with that number! The function is just a predefined, built-in routine, supplied for you by Visual Basic, which operates on the argument list and returns a value that you've got to do something with. Here are four uses of Val() that use the return value in different ways:
lblHouseNum.Caption = Val(UserAddress) ' To a label MyHouseNum = Val(UserAddress) ' To a variable OldAge = 65 + Val(txtAge.Text) ' A calculation Last = Right$(UserName, Val(Ans)) ' Another function
An argument might even be an expression. The following Val() function first concatenates the string expression used as the argument, and then returns the numerically converted value of that string argument:
Number = Val(aStr1 & aStr2)
Note: The argument list's data type doesn't always match the function's return value data type. For example, a function might take a string argument and return a number. A function might require both a string and a numeric argument, and return a string.
The built-in functions never change their arguments. The built-in functions use their arguments to create a new value: the return value.
Review: There are many built-in functions in Visual Basic that your programs can call. Programs that call functions must do something with the return values from those functions. A function might require one argument or more. If you send an argument list to a function, that function operates on those arguments and returns a single value based on the argument list.
Concept: Several of the numeric functions work to save you programming time when you're working with numbers. There are conversion functions, scientific functions, and trigonometric functions.
As you read through the following pages, don't worry about memorizing every function. Try to get a general idea of the kinds of functions supplied by Visual Basic. The functions work to save you time. If you need to convert a number or compute a standard formula, the chances are great that Visual Basic includes a function that does the work for you. For example, there is no reason to write an advanced trigonometric sine function, because Microsoft already wrote one for you.
Note: You don't have to be a math lover to use and appreciate the Visual Basic numeric functions. Actually, the less you like math, the more you'll appreciate the fact that Visual Basic supplies all these functions for you so that you never have to write the code to accomplish the same thing.
Visual Basic supplies three functions that convert single-precision and double-precision numbers to integer values. When writing applications, you might need to round numbers down or up to their nearest integers. Table 13.1 contains the three integer conversion functions.
| Function | Description |
| CInt() | Rounds fractional values of .5 and more to the next highest integer |
| Fix() | Truncates the fractional portion |
| Int() | Rounds the number down to the integer less than or equal to its arguments |
Both Fix() and Int() treat positive integers the same way. Both of the following statements return and store 14:
ans1 = Int(14.6) ans2 = Fix(14.6)
The Fix() and Int() functions behave differently for negative numbers. The remarks to the right of the following statements indicate the functions' return values:
ans3 = Int(-14.6) ' Stores -15 ans4 = Fix(-14.6) ' Stores -14
The negative number less than or equal to -14.6 is -15; hence, the return values for Int() shown in the first statement's remark.
The CInt() function returns truly rounded numbers, as shown here:
ans5 = CInt(14.1) ' Stores 14 ans6 = CInt(14.6) ' Stores 15 ans7 = CInt(-14.1) ' Stores -14 ans8 = CInt(-14.8) ' Stores -15
There are functions similar to CInt() that convert arguments of any data type to any other data type. Table 13.2 contains the rest of the data conversion functions.
| Function | Description |
| CCur() | Converts the argument to an equivalent currency data type |
| CDbl() | Converts the argument to an equivalent double-precision data type |
| CLng() | Converts the argument to an equivalent long integer data type |
| CSng() | Converts the argument to an equivalent single-precision data type |
| CStr() | Converts the argument to an equivalent string data type |
| CVar() | Converts the argument to an equivalent variant data type |
Warning: If the converted argument won't fit in the target data type, Visual Basic issues the Overflow error message shown in Figure 13.2. You've got to make sure, perhaps through an initial If statement, that the argument fits within the range of the converted data type.
Figure 13.2. Don't overflow the target data type.
Normally, the following assignment stores .1428571 in the label named lblValue:
lblValue.Caption = (1 / 7) ' Assigns .1428571
The following, however, adds precision to the answer for a more accurate calculation:
lblValue.Caption = CDbl(1 / 7) ' Assigns .142857142857143
Note: Although this statement assigns the numeric result of the CDbl function to a label, Visual Basic will allow the assignment. Although the label displays all data as test, Visual Basic lets you assign numeric values to labels so that you can display results of computations.
Don't Even Mention Other Bases! If you really want to get fancy with numeric conversions, Visual Basic supports four functions that convert their decimal base-10 arguments to octal (base-8) and hexadecimal (base-16) return values. You'll want to use these functions if you write advanced applications that deal with other number bases.
The two hexadecimal functions, Hex() and Hex$(), convert their numeric arguments to a variant and string hexadecimal value, respectively. The two octal functions, Oct() and Oct$(), convert their numeric arguments to a variant and string octal value, respectively.
If you think that you won't use these functions, forget them! These functions, especially the hexadecimal functions, come in handy for programmers who write system-level applications such as memory- and disk-maintenance programs.
The Asc() function converts its string argument to a corresponding ASCII table value. Generally, you'll pass a one-character string (or a variant that can equate to a string) value to Asc(). If the argument contains more than one character, Asc() ignores all characters following the first one.
The following statement stores the number 65 in the numeric variable named Initial because 65 is the uppercase letter A in the ASCII table:
Initial = Asc("A")
Table 13.3 lists the remaining math functions that Visual Basic provides. Many of the functions are scientific and mathematical. You may not need any or all of the functions unless you write heavy, math-intensive applications.
| Function | Description |
| Abs() | Returns the absolute value of the argument |
| Atn() | Returns the computed arc tangent of the argument expressed in radians |
| Cos() | Returns the computed cosine of the argument expressed in radians |
| Exp() | Returns the base of the natural logarithm argument |
| Log() | Returns the natural logarithm of the argument |
| Sin() | Returns the computed sine of the argument expressed in radians |
| Sqr() | Returns the square root of the argument |
| Tan() | Returns the computed tangent of the argument expressed in radians |
Tip: If you compute trigonometric values on arguments expressed as degrees instead of radians, multiply the argument by pi and divide by 180. The following expression assigns the sine of 38 degrees to a variable named sVal:
sVal = Sin(38 * 3.14159 / 180)
Review: The numeric functions will help you write programs when you need to include mathematical calculations in the code. Many business, graphics, and research applications sometimes utilize complex routines, and Visual Basic's math functions will help shorten your programming time and improve the accuracy of your code.
Concept: There are several Visual Basic string functions that manipulate string data better than most other programming languages allow. The string functions allow you to strip away characters from string data and change strings in various ways.
The Visual Basic programming language supports strings using the variable-length and fixed-length strings that you've seen defined throughout the first half of this book. The string manipulation provided by Visual Basic is perhaps more powerful than any other non-BASIC programming language in widespread use today.
You've already seen the Chr$() function that converts an ASCII number to its character equivalent. (There is a related Chr() function that returns a character in the variant data type also.) The Str$() (and the related variant-returning Str() function) converts a number to a string.
Tip: Convert numbers to strings when you want to display numeric quantities inside a message box.
Suppose that the user's age were stored in a numeric variable named Age. If you wanted to display the user's age in a message box, you couldn't do so without first converting the age to a string value as follows:
MsgBox "Your age is now" & Str$(Age)
The string case-conversion functions convert their string arguments to uppercase or lowercase character strings. Table 13.4 lists these functions.
| Function | Description |
| LCase() | Returns the string argument as a variant data type that's all lowercase letters |
| LCase$() | Returns the string argument as a string data type that's all lowercase letters |
| UCase() | Returns the string argument as a variant data type that's all uppercase letters |
| UCase$() | Returns the string argument as a string data type that's all uppercase letters |
Tip: The Variant versions of all string functions are less efficient than the string versions. Therefore, use the string versions as often as possible.
If the argument already contains one or more characters in the target case, the functions leave those characters alone. The remarks following these statements indicate the function return values:
lowerName = LCase("Larry") ' Returns larry
upperName = UCase("Smythe") ' Returns SMYTHE
Definition—A substring is a portion of a string.
Visual Basic contains three string functions that return left, center, or right portions of a string. These are the Left$(), Mid$(), and Right$() functions. All three functions are said to return a substring value. Here are the formats of these functions:
Left$(StringVal, length) Right$(StringVal, length) Mid$(StringVal, startVal, length)
Note: The Mid$() function is called the midstring function.
The Left$() function returns length characters from the StringVal. The StringVal might be a string constant or variable. Likewise, Right$() returns length characters from the StringVal. Mid$() returns length characters from the StringVal beginning at the startVal character.
The remarks following these statements indicate the function return values:
Title = "Something Good!" lTitle = Left$(Title, 4) ' Some rTitle = Right$(Title, 5) ' Good! mTitle = Mid$(Title, 5, 8) ' thing Go
Figure 13.3 shows how Visual Basic strips these substrings from the longer string values.
Figure 13.3. Substring functions pull substrings from strings.
The Len() function returns the number of characters stored in strings. Often, you'll have to adjust control sizes to hold long strings. You can use the Len() function as a guide to calculate how wide a control must be. The following statement stores 14 in the variable named Length:
length = Len("Blue and Green")
Note: The Len() function works for numeric values as well. If you pass a numeric variable, constant, or expression to Len(), Len() returns the amount of memory needed to hold that numeric value.
The LTrim$() and RTrim$() functions trim extra spaces from the beginning or end of a string. If extra spaces don't exist, the LTrim$() and RTrim$() functions do nothing. LTrim$() returns the argument's string without any leading spaces. RTrim$() returns the argument's string without any trailing spaces. The Trim$() function handles both jobs by trimming both leading and trailing spaces from a string.
Here are the formats of the string-trimming functions:
LTrim[$](StringExpression) RTrim[$](StringExpression) Trim[$](StringExpression)
Note: There are also equivalent variant functions called LTrim(), RTrim(), and Trim().
The following statements trim spaces from the beginning, end, or both sides of strings:
LStr1 = LTrim$(" Jonah") ' Stores Jonah
RStr2 = RTrim$("Jonah ") ' Stores Jonah
AnySt3 = Trim$(" Jonah ") ' Stores Jonah
Without the trimming functions, the spaces are copied into the target variables along with the name Jonah.
Earlier, you learned how to use Str$() to convert a number to a string. Because Str$() always converts positive numbers to strings with a leading blank (where the imaginary plus sign appears), you can combine LTrim$() with Str$() to eliminate the leading blank. The first of the following two statements stores the leading blank in st1. The second uses LTrim$() to get rid of the blank before storing the string into st2.
st1 = Str$(234) ' Stores " 234" st2 = LTrim$(Str$(234)) ' Stores "234"
Review: The string functions manipulate strings and return values based on string arguments. As you write more powerful programs, you'll need to extract substrings and convert the case of strings in various ways to display string values on the form and in controls.
Concept: There are a handful of general functions that don't fall into a strict numeric or string category. These general-purpose functions add power to your programming skills. This section explains how to detect data types using the Is...() and VarType() functions. You may not see a use for these functions quite yet, but familiarize yourself with them. In Lesson 8, you'll learn how to pass data back and forth between Visual Basic routines, and there are times when you'll need to know which data type was passed to you using one of the functions taught here.
Table 13.5 contains data inspection functions, often called the Is...() functions. When you store a data value in a variant variable (which can accept any data type), Table 13.5's functions return a true or false result that indicates whether the argument can be converted to a specific data type.
| Function Name | Description |
| IsDate() | Determines whether its argument can be converted to a valid date |
| IsEmpty() | Determines whether its argument has been initialized with any value since the argument's original definition |
| IsNull() | Determines whether its argument holds a Null value (such as an empty string) |
| IsNumeric() | Determines whether its argument holds a value that can be converted to a valid number |
The following code ensures that a valid string appears in the variable named ans before applying a UCase$() function:
If IsString(ans) Then NewAns = UCase$(ans) Else MsgBox "You didn't type a letter!" End If
Empty variables differ from Null values and zero values. Empty variables indicate that nothing has been entered into variables. The IsNull() function checks to see whether its control argument contains a Null value.
Tip: Use IsNull() to see whether a control or field on a form contains data. Use IsEmpty() just for variables.
The VarType() function determines the data type of its argument. Table 13.6 lists the return values from the VarType() function. VarType() returns no values other than the nine listed in the table.
| Return | Description |
| 0 | The argument is Empty |
| 1 | The argument is Null |
| 2 | The argument is Integer |
| 3 | The argument is Long |
| 4 | The argument is Single |
| 5 | The argument is Double |
| 6 | The argument is Currency |
| 7 | The argument is Date |
| 8 | The argument is String |
Stop and Type: Listing 13.1 makes sure that the user entered a value into the txtAge text box control.
Review: The general-purpose functions return values that indicate data contents and data types. You can use these functions to see whether variables and controls have been initialized before calculating with those values.
Input: Listing 13.1. Checks to make sure that the user entered a value.
1: If IsNull(txtAge.Text) Then 2: MsgBox "You didn't type anything!" 3: Else 4: MsgBox "Thanks for entering a value." 5: End If
Analysis: Line 1 ensures that the user has typed something in the control named txtAge. Subsequent code could then use the VarType() function to make sure that the user entered a value of the correct data type required by the user.
Write a program that stores the 256 ASCII characters (from ASCII 0 to ASCII 255) in a string array that's defined to hold 256 elements.
