QBASIC Programming


QBasic is a programming language, created by Microsoft.  It is based upon the original language BASIC (Beginners All-purpose Symbolic Instruction Code). In the early days of computers, most people wrote and ran their own programs. This led to the conclusion that everybody that was going to use a computer needed to learn how to program. Courses like "Computers and Society" were substantially about programming.
Now, however, it is clear that most people who use computers are not programmers, but use programs (applications) written by others; applications such as word processors, spreadsheets and database programs. Today, some of these can involve programming. Here, building formulae in Excel, and with the Paper and Pencil Computer, you have had some experience with programming. Even major word processors such as Microsoft Word contain built-in programming languages for customizing work; for example summing a column in a table as in the Ever Ripe document. Usually, however, anything substantial is done by specialists within an organization. In studying the impact of computers on society, it can still help to understand something about programming. But this is nowhere near the amount of programming that was done to create the applications.
What is a Computer Program?
A computer program is a list of instructions for a computer to execute. Programs come in several varieties:
  • Programs that a computer can execute directly are in binary "machine language." These are called executable modules. Common extensions are exe, com, and dll. In this form, instructions have two parts, the operation code which says what action to take (addition, subtraction, load, store, print, etc.) and the address, which says which memory location to use. In machine language, both parts are in binary code. In the original Paper and Pencil Computer, STOP was 000, ADD was 001, SUB was 010 (counting in binary, of course), and so forth. Programming in machine language is very difficult and, for this reason, rare. Each type of (micro) processor has its own machine language, so that programs written for one processor are not compatible with other types.
  • Slightly easier is "assembler," which uses mnemonic codes which the computer translates into binary codes. This is the case with the symbolic names STOP, ADD, SUB and the similar commands for the Paper and Pencil Computer. However, in full assembler language, memory addresses also have symbolic names, which the computer assigns to definite memory locations. Assembler language programs must be translated into machine language by the computer. Each type of (micro)processor has its own assembler language, so that programs written for one processor are not compatible with other types.
  • Most programming is done using so-called "higher level languages" such as Basic, Fortran, Cobol and C. Here the statements are more like English, or at least algebra, and work more the way humans calculate, for example
    "x = a + b." Programs written in higher level languages also must be translated or compiled into machine language, but each type of processor has its own compiler for each computer language, so that programs written in higher level languages can be run on many different processors, by using that processor's compiler.
  • The newest type of computer language is the so-called 4GL, for Fourth Generation Language such as C++ and Java. Programs in 4GL languages must also, of course, be translated or compiled into machine language, but here the programmer need not program exactly what the computer should do, but instead sets up "objects" and "methods" for objects to use when they interact.
With a standard higher-level program, there are two program files (and sometimes more): the file with the binary codes, also called "machine language," that the computer could execute (the "executable" file with the exe extension, but other variations are used in addition) and the "source file" with the English-like words. The programmer writes the source file, which usually has one instruction per line, and the computer translates that into the executable file, using a computer program that can be called either an "assembler" or "compiler." In this case, the entire program is translated into binary codes or machine language, and then executed all at once.
In an alternate scheme, there is only a source file, and the source file is compiled into machine language line by line, as it is executed (at “run time”). This is slower to execute, but for short programs it can be more convenient, and since computers are so fast today, can still run quickly in terms of human reaction times. In this case, the computer program that does the translation from source code to machine language is called an "interpreter." In the case of interpretation, the source program is translated into machine language line by line on the fly as it is executed, and there is no machine language file.
Here you will examine some pre-written programs to see how they work, using the QBASIC interpreted programming language. DOS always came with a built-in programming language. Earlier DOS versions came with GWBASIC, but later, QBASIC became the standard. Early versions of Windows came with a programming language, but starting with Windows 95, programming languages became for-sale add-ons.
Programming has several steps:
  1. Design of the program (we will skip that step here, but in real-life programming it is critical, and often determines success or failure of the whole project).
  2. Entering the program, usually via the keyboard. Programs are usually text files, although they may have extensions other than txt (QBASIC, for example, uses bas). However, even with other extensions, program files can be edited with text editors such as NotePad. The program at this point is in a programming language, and is generically known as "source code" (the form that can most easily be read and understood by humans.
  3. Dubugging (easy part): fixing syntax problems. This is the easiest part of debugging. All programming languages have a grammar or syntax, that is formal rules that all statements must comply with. For example, in QBASIC, two variables must be separated by an operator that combines them, such as +, -, * (multiplication) or /. Each program statement must comply with the syntax, which means that the computer will be able to execute it. This by no means assures that the program will do what you want, however.
  4. Debugging (hard part) execution. The source language statements must be translated into machine code that the computer can directly execute, either by compilation or assembly ahead of time, or by interpreting line-by-line as the program is run. QBASIC, again, uses the second method, interpretation. As the program is executed, the programmer must verify that the program is actually doing what was intended. This is also debugging, and is more difficult that the first step.
QBASIC is designed for small programs and quick results. It has one outstanding feature for beginners; each program line is checked for syntax after you leave the line with <Enter> or the up or down arrow keys. It may not do what you want, but the check ensures that it is legal. If the line is OK, it is put into a standard format with:
  • all mathematical operators such as + and - have a space on each side
  • all QBASIC commands and other keywords are capitalized. Examples of commands and keywords are INPUT (get user input from keyboard) and PRINT (display on the screen).
If the line is not legal, there is no change from the way you typed it; this is a signal to look for a problem and edit the line to fix the problem(s).
Notice that if you enter lines already in the standard format, there will be no change if the line is legal. Therefore, it pays to enter lines without spaces around the operators, and with the keywords in lowercase.

Starting up

Now if your so new that you don't even know where to put your code then read on, if you have
Qbasic all set up then skip to 'SECTION 2'.

Right, well you will need a Qbasic Interpreter, or the Compiler.  Try looking n the web for an
the QBasic .exe
OK, you have the .exe now so all you need to do is run it.  If you can run it simply by double clicking then good for you, if not then you have to use the DOS Command Line. If it all works then your screen should go blue and you have (more or less) a mouse cursor. This is where you put your code to run.  You can check whether you have got the interpreter or the compiler by clicking on the RUN menu, if you see a COMPILE option then you have compiler, if not then you have the interpreter.  It doesn't really matter which you have (not for my tutorials anyway).  The compiler is generally faster and allows you to make executable from your code.
OK then let’s get going on actually learning.
The first thing that I shall teach you is CLS.  What this does is clear the screen, it will make the screen blank, you can use this to clear text and graphics from the screen.
This is all fine and well, but as of yet you have nothing to clear from the screen. So what about learning PRINT this command can be used to make the computer write something on the screen, at first its name can be deceiving, but you'll understand later. So how do we use it?..  Its easy really, look at the following program:

CLS
‘Test
PRINT  "HELLO WORLD."

Lets step through:

First of all the CLS command will clear the screen.
Second we reach the PRINT command as you can see from the code the words 'HELLO WORLD. ' Are enclosed in speach marks.  This is how you use PRINT.
Try using PRINT to write other things on the screen, experiment with CLS and PRINT.
Writing words isn't the only thing that PRINT can do, it can do some math too.
Have a look at this:
CLS

PRINT "12 TIMES 12 IS:"
PRINT 12*12
'test

You should already know what the first two lines do so I will go on to the final line.  Most of you will be able to figure out what it does, but for those of you that can't its simple * means multiply so 12*12 means 12 multiplied by 12. And print will write the answer on the screen.
Print can do more, but I'll leave at this for the minute. Before I go I'll just tell you this, if you have just the word PRINT on its own, without any other words or numbers then it will just print a blank line and move onto the next. That’s all for this one.

VARIABLES
---------
Those of you with knowledge of algebra, science, etc. will know what a variable is.  A variable is a symbol(s) that holds a value, this could be numerical or text.  In QBASIC a variable is assigned a value to hold, this value can be anything.  You can tell what kind of thing a variable has from a symbol added on to the end. For the moment we will look at two of them the % (percent) sign and the $ (Doller) sign.  In QBasic they mean different things.  The % means an integer and the $ means string (text). variables don't have to have a sign on the end, these usually have a numerical value.
LET
A new command, LET this command is very useful it can assign a value to a variable:

'--------------------
LET A$ = "HELLO"
LET B$ = "WORLD."
'--------------------

This short program will assign the memory space 'A$' with the value of 'HELLO' and the space 'B$' with the value 'WORLD.' This is all fine and well but they're not much use to us like this.  We need to call back a command, previously taught in the first tutorial.  The PRINT command. Now, we know that PRINT can write words and numbers on the screen provided that they are typed with the syntax (a syntax is how a command is set out e.g. PRINT [words]) but it can also be used to print variables.  This is obvious when you think about it! Have a look at the following program:


CLS
LET A$ = "HELLO "
LET B$ = "WORLD."

PRINT A$ + B$

You will see that it simply an update to the first example, but how does it work? Well when you look at it you see that in fact you know how most of it works but what about the final PRINT statement? As you can see it doesn't use the speech marks.  PRINT substitutes the variables for their values and writes the result on the screen.  The + sign works differently to that of the mathematical +, in that in our example it joins the two variables together. The output of the program is this:

HELLO WORLD.

But 'OH MY' what happens when you actually want to ADD two numerical values together if the + sign is used to join them together!  Don't worry its easy, QBasic follows these rules when using the plus sign:

            If + is used between strings (text) then join them together.
            If + is used between numerical values then work as a mathematical operator.
            If + is used between a numerical value and a string then cause an error.


If all this was complicated then go back and read it over, also you could look through QBasic's help file for more information. Another type of joining symbol is the semi-colon (;) this one can join loads of things together, even a string and a number.


INPUT
This is another new command, that mixes PRINT, LET & Keyboard Inputs all together!
The best way to learn is to do, but how can you do something when you don't even know how to? Confused?  Well, anyway set your eyes on this:
CLS
INPUT "WHAT IS YOUR NAME"; N$

Let me explain the INPUT statement.  The first part of it (the "WHAT IS YOUR NAME" part) works just like the PRINT command so there's nothing complicated there.  However the last part is a bit different. In a way it’s similar to LET! Basically when you run the program you get the words WHAT IS YOUR NAME followed by a question mark.  You also get a curser added to the end; this allows you to enter words and numbers from the keyboard. Once you have typed in what you need press Enter and QBasic will assign the text you typed to the variable N$ (Just like LET).
Well, now that N$ has a value we could use PRINT to write it on the screen.  The program looks like this:
CLS
INPUT "WHAT IS YOUR NAME"; N$
PRINT N$
If you wanted you could put a CLS statement in between the INPUT and PRINT lines.
Whenever QBasic encounters an INPUT statement it stops execution and waits for a reply from the keyboard.
Now feast your eyes on this:
CLS
INPUT "WHAT US YOUR NAME"; NAME$
INPUT "HOW OLD ARE YOU"; AGE%
CLS
PRINT "HELLO " + NAME$
PRINT "YOU ARE" ; AGE% ; "YEARS OLD!"

By now should be able to understand this.  Remember the semi-colon and the + are used for joining and % means the variable type is an integer.

DIM
The first thing I'm going to teach you is DIM this can be very useful when using variables. For example, say you had a program that required 500 variables all based on the same thing, lets say 500 names in an address book, and you don't want to have to type out 500 different variables. Ever since the beginning of computer programming, programmers have tried to find quicker and easier ways to do something.  This is one of them. DIM can be used to create loads of variables in just one command.  It works like this:
DIM NAMES$ (500)
This an 'array' of names from 0 to 500 (so 501 different variables made here)
To give one of the variables a value does the following:
LET NAME$(5) = "OLD MAN"
This will give the 6th variable the value 'OLD MAN' (Remember that zero counts as a variable) Well that wasn't too hard now was it.  So this should be a breeze:

DIM NAME$ (500)
LET N% = 5
LET NAME$(5) = "OLD MAN"
CLS
PRINT NAME$(N%)

The number that is used with an array can be a variable too; this is shown in the program above. The output from the program should be obvious:   OLD MAN As an array can be called using a variable this means that you can create nested arrays:
DIM NAME$ (500)
DIM NUM% (10)
LET N% = 4
LET NUM%(4) = 5
LET NAME$(5) = "OLD MAN"
CLS
PRINT NAME$(NUM(N%))

If you don't understand this straight away then don't worry just read over it few times, I'm sure you'll get it. Arrays are usually defined at the beginning of a program, or at least before they are used.

GOTO
This is a can be a useful statement, it is used to make the program execution move to another location in the program. To use GOTO you have to fisrt of all make a 'tag' for the program to jump to.

CLS
PRINT "WHAT A NICE DAY"
GOTO COMEHERE
PRINT "GOODBYE 1"
COMEHERE:
PRINT "GOODBYE 2"
As you can see a 'tag' must have a colon at the end. When run you should get this output:

WHAT A NICE DAT
GOODBYE2
This is because the GOTO moves or jumps to the tag and continues from there.  You must not have two tags with the same name.  Tags are used by GOTO as a 'look up' spot, when they encountered during normal execution they are simply ignored. It is possible to make and endless loop using goto, look:
CLS
START:
PRINT "HELLO"
GOTO START
This program will go on forever, in an endless loop.  To stop it press CTRL & Break buttons to stop the program manually. Well that’s all there is to know about GOTO!
Let’s move onto GOSUB

GOSUB
GOSUB works similar to GOTO but with one difference, have a look at this:

CLS
PRINT "WHAT A NICE DAY"
GOSUB COMEHERE

PRINT "GOODBYE 1"
END
COMEHERE:
PRINT "GOODBYE 2"
RETURN
This program introduces you to two new commands, the END command and the RETURN command. END is a basic command which does exactly what it is called it will cease execution regardless of whether there is still more code or not. The RETURN statement is used with GOSUB to return to the line AFTER the initial GOSUB.
So the output is:

WHAT A NICE DAY
GOODBYE 2
GOODBYE 1

Have a go practicing what you have learnt so far.

FOR...NEXT
This is actually two statement, FOR and NEXT. These are used to make a different type of loop. Look at the following example:
FOR N% = 1 TO 20
CLS
PRINT "HELLO WORLD ";N%
NEXT N%

This program will look around 20 times. The FOR statement sets up a loop, this stuff directly after is a test, the variable N% is used, and every time the program loops it is incremented by 1 and once it reaches 20 the loop breaks and continues with the rest of the program. This is another example of this type of loop

FOR X = 1 TO 100
            FOR Y = 1 TO 100
                        CLS
                        PRINT "X:";X
                        PRINT "Y:";Y
            NEXT Y
NEXT X

This example uses nested loops and the values are printed on the screen.  This type of program could be used for graphics where a pixel is made to draw a line. I have also used tabs to tidy up my program, in long programs tabs can make the code easier to read.
When this program is run you will find the text written on the screen flashes a lot, this is
Because the CLS is constantly clearing the screen, an improvement on this program is this:

FOR X = 1 TO 100
            FOR Y = 1 TO 100
                        LOCATE 1,1
                        PRINT "X:";X
                        PRINT "Y:";Y
            NEXT Y
NEXT X

The LOCATE statement can be used to set the location of a PRINT statement, the first value is the row number and the second is the column number.  Using this method also increases the speed of the execution. Try to get to grips with FOR..NEXT loops, GOTO, GOSUB, LOCATE, etc. they can be very powerful tools when making larger, more implicated programs.

Let’s begin with some loops stuff.  You should already now about using GOTO, GOSUB and FOR..NEXT statements but what about DO..LOOP or WHILE...WEND?
I don't often use the WHILE..WEND statements but I'll teach you them anyway.
The WHILE..WEND statements are similar to the FOR..NEXT loop but with a few differences.  Take a look at this:

WHILE N < 100
PRINT N
N=N+1
WEND

The program above will loop around 'while' N < 100 once the variable reaches the set number it will stop looping and continue as normal. That's all there is to know about WHILE...WEND, here is a different type of loop, very much like the one just shown.
DO...LOOP
These are very much similar as to the ones above but have better control with them. 
DO
PRINT N
N=N+1
LOOP UNTIL N = 100

The program above will do exactly the same thing as the previous one it has just been set out differently.  The DO...LOOP statements can not only use the UNTIL command but also the WHILE.
DO
PRINT N
N=N+1
LOOP WHILE N < 100

Notice that on the bottom line the same syntax has been rewritten to do exactly the same thing! It usually doesn’t matter which one you use. With the DO...LOOP method you don't have to but the test on the bottom line (e.g.  The line with the word LOOP) you could put it on the the DO line. 
DO
PRINT N
N=N+1
LOOP UNTIL N = 100
DO UNTIL N = 10
PRINT N
N=N+1
LOOP
One other thing about loops is that if you don't have a test then the loop will continue forever! Well now you're a master of loops!  Practice using what you know to make your own programs too.
IF..THEN..ELSE
An IF statement or 'statement block' can be used to evaluate variables or other things and execute code based on the result. Look at this IF statement and try to guess how it works:

CLS
LET N = 5
IF N = 5 THEN PRINT "N IS 5"
IF N = 10 THEN PRINT "N IS 10"

The program starts off by making the variable N the value of 5 The following two statements are IF's  they perform tests on the variable and execute a command as required.  The output from this would be 'N IS 5' you can see why, I won't bother explaining. IF's can also make more complex lines:
CLS
LET N = 5
IF N = 5 THEN PRINT "N IS 5" ELSE PRINT "N IS NOT 5"

This program is similar to the one above but on the line with the IF an extra piece has been added on 'ELSE PRINT "N IS NOT 5" ‘ This piece is executed if and only if N doesn't equal 5. Take a look at this example:
CLS
LET NAME$ = "DAVID"
IF NAME$ = "JANE" THEN PRINT "HI JANE" ELSE PRINT "NICE DAY?!"

When you run this program the output is 'NICE DAY?!'  the 'HI JANE' part is not shown because NAME$ is not equal to 'JANE'. Now onto statement blocks.  These do exactly the same as what you've just seen except they can execute more than just one statement:
CLS
LET NAME$ = "DAVID"
IF NAME$ = "DAVID" THEN
            PRINT "HI THERE"
            PRINT "DAVID"
END IF
Notice the END IF?  This tells the computer that all the code enclosed within the IF and the END IF is to be executed when the test is TRUE and that it should not be executed otherwise. You can also add the ELSE command into a statement block:
CLS
LET NAME$ = "DAVID"
IF NAME$ = "DAVID" THEN        
            PRINT "HI THERE"
            PRINT "DAVID"
ELSE
            PRINT "NICE DAY?!"
END IF
Using what you have learnt already you should be able to see how this works.  Here's a hint the final output is:
HI THERE
DAVID
Practice using IF statements and statement blocks, they can be very powerful.  Also in larger programs try to use tabs they can help in decoding and for later review.

SELECT CASE
This is another way of testing things.  SELECT CASE statement blocks can be used for branching and be used to replace IF's when a single variable can have many different results. Take a look at another example:

CLS
FOR N = 1 TO 5
            SELECT CASE N
                        CASE 1
                                    PRINT "MONDAY"
                        CASE 2
                                    PRINT "TUESDAY"
                        CASE 3
                                    PRINT "WEDNESDAY"
                        CASE 4
                                    PRINT "THURSDAY"
                        CASE 5
                                    PRINT "FRIDAY"
            END SELECT
NEXT N

You should already know what the FOR and CLS do so I'll go straight onto the SELECT CASE. Some of you may already be able to see what it does, but I'll tell you anyway.
The first line SELECT CASE N tells the computer to take out a notepad and get ready for some experiments on the variable N. The next line CASE 1  can be translated into an IF statement so.. IF N = 1 THEN .....
Anyway, the line(s) directly below that are what are executed if this is true.
This is the same for the other 'CASE ' lines. The END SELECT line means stop testing.  Simple! A different type of CASE line can be added, this is CASE ELSE.  It is the same as an IF's ELSE statement.  If we put this in the program above we have:

CLS
FOR N = 1 TO 7
            SELECT CASE N
                        CASE 1
                                    PRINT "MONDAY"
                        CASE 2
                                    PRINT "TUESDAY"
                        CASE 3
                                    PRINT "WEDNESDAY"
                        CASE 4
                                    PRINT "THURSDAY"
                        CASE 5
                                    PRINT "FRIDAY"
                        CASE ELSE
                                    PRINT "SATURDAY - SUNDAY"
            END SELECT
NEXT N
Branching like what you've just been shown can be extremely useful in replacing loads of IF's! That's not to say that you can just use SELECT CASE instead of IF.




QBASIC Functions and Statements


 
Functions and Statements
ABS Function                     
 APPEND
  ACCESS                            
AS
  ALIAS                             
ASC Function
  AND Operator                       
ATN Function
  ANY
  BASE                              
BLOAD Statement
  BASIC Program Lines               
BSAVE Statement
  BEEP Statement                    
BYVAL
  BINARY
  CALL Statement                    
CLS Statement
  CALLS Statement                   
COLOR Statement
  CALL ABSOLUTE Statement           
COM Statement
  CALL INTERRUPT Statement          
COMMAND$ Function
  CASE                              
COMMON Statement
  CDBL Function                      
CONST Statement
  CDECL                             
COS Function
  CHAIN Statement                   
CSNG Function
  CHDIR Statement                   
CSRLIN Function
  CHR$ Function                     
CVD Function
  CINT Function                     
CVDMBF Function
  CIRCLE Statement                  
CVI Function
  CLEAR Statement                   
CVL Function
  CLNG Function                     
CVS Function
  CLOSE Statement                    
CVSMBF Function
  DATA Statement                    
DEFINT Statement
  Data Types                        
DEFLNG Statement
  DATE$ Function                    
DEFSNG Statement
  DATE$ Statement                   
DEFSTR Statement
  DECLARE (BASIC) Statement         
DIM Statement
  DECLARE (Non-BASIC) Statement     
DO...LOOP Statement
  DEF FN Statement                  
DOUBLE
  DEF SEG Statement                 
DRAW Statement
  DEFDBL Statement                  
 $DYNAMIC Meta command
  ELSE                              
ERDEV Function
  ELSEIF                            
ERDEV$ Function
  END Statement                     
ERL Function
  ENDIF                             
ERR Function
  ENVIRON Statement                 
ERROR Statement
  ENVIRON$ Function                 
EXIT Statement
  EOF Function                      
EXP Function
  EQV Operator                      
Expressions and Operators
  ERASE Statement
  FIELD Statement                  
 FOR...NEXT Statement
  FILEATTR Function                 
FRE Function
  FILES Statement                   
FREEFILE Function
  FIX Function                      
FUNCTION Statement
 GET (File I/O) Statement          
GOSUB Statement
  GET (Graphics) Statement          
GOTO Statement
  HEX$ Function
  IF...THEN Statement               
INPUT$ Function
  IMP Operator                     
 INSTR Function
  $INCLUDE Meta command             
INT Function
  INKEY$ Function                   
INTEGER
  INP Function                      
IOCTL Statement
  INPUT Statement                   
IOCTL$ Function
  INPUT # Statement                 
IS
KEY Statement                     
KILL Statement
KEY(n) Statement
  LBOUND Function                  
 LOCATE Statement
  LCASE$ Function                   
LOCK...UNLOCK Statements
  LEFT$ Function                    
LOF Function
  LEN Function                      
LOG Function
  LET Statement                     
Logical Operator Truth Table
  LINE (Graphics) Statement         
LONG
  LINE INPUT Statement              
LOOP
  LINE INPUT # Statement            
LPOS Function
  LIST                              
LPRINT Statements
  LOC Function                      
LSET Statement
  LOCAL                             
LTRIM$ Function
  MID$ Function                     
MKL$ Function
  MID$ Statement                    
MKS$ Function
  MKD$ Function                     
MKSMBF$ Function
  MKDIR Statement                   
MOD
  MKDMBF$ Function                  
Modules and Procedures
  MKI$ Function
  NAME Statement                     
NOT Operator
  NEXT
  OCT$ Function                     
ON UEVENT Statement
  OFF                               
ON...GOSUB Statement
  ON                                
ON...GOTO Statement
  ON COM(n) Statement                
OPEN (File I/O) Statement
  ON ERROR Statement                
OPEN COM Statement
  ON event Statements               
Operator Precedence Rules
  ON KEY(n) Statement               
OPTION BASE Statement
  ON PEN Statement                   
OR Operator
  ON PLAY(n) Statement              
OUT Statement
  ON STRIG(n) Statement             
OUTPUT
  ON TIMER(n) Statement
  PAINT Statement                   
POINT Function
  PALETTE Statements                
POKE Statement
  PCOPY Statement                   
POS Function
  PEEK Function                     
PRESET Statement
  PEN Function                     
PRINT Statement
  PEN Statement                     
PRINT USING Statement
  PLAY(n) Function                  
PRINT # Statement
  PLAY (Music) Statement            
PSET Statement
  PLAY (Event Trapping) Statements  
PUT (File I/O) Statement
  PMAP Function                     
PUT (Graphics) Statement
  RANDOM                            
RETURN Statement
  RANDOMIZE Statement               
RIGHT$ Function
  READ Statement                    
RMDIR Statement
  REDIM Statement                   
RND Function
  REM Statement                      
RSET Statement
  RESET Statement                   
RTRIM$ Function
  RESTORE Statement                 
RUN Statement
  RESUME Statement
  SADD Function                     
SPC Function
  SCREEN Function                   
SQR Function
  SCREEN Statement                  
STATIC Statement
  SEEK Function                     
$STATIC Meta command
  SEEK Statement                    
STEP
  SELECT CASE Statement             
STICK Function
  SETMEM Function                    
STOP Statement
  SGN Function                      
STR$ Function
  SHARED Statement                  
STRIG Function
  SHELL Statement                   
STRIG Statements
  SIGNAL                            
STRING
  SIN Function                      
STRING$ Function
  SINGLE                            
SUB Statement
  SLEEP Statement                   
SWAP Statement
  SOUND Statement                   
SYSTEM Statement
  SPACE$ Function
  TAB Function                      
TIMER Statement
  TAN Function                      
TO
  THEN                              
TROFF Statement
  TIME$ Function                    
TRON Statement
  TIME$ Statement                   
TYPE Statement
  TIMER Function
  UBOUND Function                   
UNLOCK Statement
  UCASE$ Function                   
UNTIL
  UEVENT Statement                  
USING
  VAL Function                      
VARSEG Function
  Variable Scope Rules              
VIEW (Graphics) Statement
  VARPTR Function                   
VIEW (Text) Statement
  VARPTR$ Function
  WAIT Statement                    
WINDOW Statement
  WEND                              
WRITE (Screen I/O) Statement
  WHILE...WEND Statement            
WRITE (File I/O) Statement
  WIDTH Statements
  XOR Operator

Computer science, Number Systems, Boolean Algebra,QBASIC, C tutorial, SQL Tutorial, HTML 5 tutorial

Follow by Email