A BASIC (Beginner's All-purpose Symbolic Instruction Code) általános célú programozási nyelvet 1964-ben készítette Kemény János és Thomas Kurtz a Dartmouth College-ben, oktatási céllal.
A nyelv alapjait a Fortran programozási nyelv alapján tervezték meg. A nyelv interpretált nyelv, azaz a programot futás közben fordítja a gép saját nyelvére.
Elterjedésében nagyban közrejátszottak az 1980-as években elterjedt számítógépek, melyeknél gyakran a számítógéppel egybeépítve adták a BASIC értelmezőt. Ezekben a különböző számítógépeken futó BASIC programok szinte mindig inkompatibilisek voltak egymással: az egyik géptípusra írt programot más számítógéptípusokon nem lehetett futtatni.
Nagy lökést jelentett a nyelv elterjedésében a DOS operációs rendszer elterjedése, melynek újabb verzióiba beépítették a Qbasic nevű BASIC változatot. A Qbasic szoros rokonságban állt a Microsoft QuickBasic fejlesztőeszközével, de nem tudott futtatható fájlt készíteni.
Az 1990-es évek elejére sokan leírták a Basicet, mivel a Basic alapú mikroszámítógépek kora lejárt, PC-n a C/C++ és a Pascal nyelvek vívtak ki vezető szerepet. A Microsoft 1991-ben kiadta a Visual Basicet, ami a legnagyobb megújítása lett a nyelvnek: a QuickBasic strukturált Basic nyelvjárása eseményvezéreltté vált, megjelentek benne objektumorientált vonások, így hatékony és egyszerűen használható Windows fejlesztőeszközzé vált. Tovább segítette a nyelv terjedését két variánsa: Visual Basic for Applications (VBA) a Microsoft Office programcsomag makrónyelvévé, a Visual Basic Script a Windows operációs rendszer scriptnyelvévé vált.
A Visual Basic 2002-ben jelentős átalakításon esett át: megjelent a Visual Basic .NET, ami teljesen objektumorientálttá tette a nyelvet, a .NET keretrendszerhez igazodva. A Visual Basic .NET-ben gyakorlatilag csak a kulcsszavak emlékeztetnek a klasszikus Basicre, a változások olyan mélyrehatóak voltak, hogy még a klasszikus Visual Basickel sem kompatibilis visszafele. Emiatt több kritika érte és éri, sokak szerint csak nevében Basic, a legközelebbi rokonságban a C# nyelvvel van.
Noha a Microsoft-féle irányvonal a legelterjedtebb a nyelv fejlesztésében, a Basicnek rengeteg nyelvjárása és értelmezőprogramja van. Könnyű tanulhatósága miatt sokan kezdik a programozást vele. Több speciális célú Basic-változat létezik, például mikrovezérlők programozására vagy játékfejlesztésre.
Jellemzők Adattárolás, változók A BASIC nyelvjárások nagy részében nem kell a változókat deklarálni. Az új változókat ebben az esetben a parancsértelmező futásidőben hozza létre a nevük első előfordulásakor. Ez hibalehetőséget jelent annyiban, hogy az elgépelt nevű változók is létrejönnek így. Az idők folyamán azonban több megoldás is létrejött:
Az első változatban, a Dartmouth Basic-ben egy, illetve kétjegyű változóneveket használhattunk, az első jegy betű (A-Z), az (opcionális) második számjegy (0-9), így a BASIC összesen 11x26=286 változót tudott kezelni (A-Z, A0-A9,..., Z0-Z9).
Az értékadás a LET kulcsszóval történt (például LET x=26), ami több későbbi változatban is benne maradt, bár idővel fölöslegessé válva kikopott.
A változók A Dartmouth Basicben mind lebegőpontos számok voltak, később megjelentek más típusok is. Ezeket általában a változónév végén álló karakterek jelzik: % - egész szám (például a%=5) ! vagy nincs – (egyszeres pontosságú) lebegőpontos szám (például a=5.1) # – kétszeres pontosságú lebegőpontos szám (például a#=5.5) $ – szöveges változó (string) (például a$="Cica") Megjegyzendő, hogy a stringeket kezelő függvények neve is $-re végződik általában.
Egyes verziók lehetővé tették a változók típusának előzetes deklarációját, a DEFINT, DEFSTR, ... utasításokkal: DEFINT A-Z: REM minden változó legyen egész DEFSTR S: REM az S-sel kezdődő változók stringek
Idővel ez a jelölésmód korszerűtlenné vált, rontotta a nyelv használhatóságát. Újabb értelmezőkben - mint a Quick Basic vagy a Visual Basic - elterjedt az a megoldás, hogy a tömbök deklarására használt DIM parancsot lehet használni. Példa (Visual Basic):
Dim x As Long Dim y As String x=123456 y="Cica"
A "klasszikus" Visual Basic bár nem tette kötelezővé a változók deklarálását, az Option Explicit fordítási direktíva bekapcsolásával kötelezhette magát erre a felhasználó. A Visual Basic .NET a CLI-kompaibilitás miatt nem támogatja a deklarálatlan változókat.
Ez eredeti változatban az egyetlen használható típus-konstrukció a tömb, a tömböket a DIM utasítással lehet deklarálni ('dimenzionálni'), egyes változatok a dimenzionálatlan tömböket automatikusan tízelemű tömbként dimenzionálták, pl:
DIM x(22): REM szabályos dimenzionálás LET y(3)=3: REM implicit dimenzionálás: DIM y(10), nem minden verzióban
A tömbindexek általában eggyel kezdődtek, egyes megvalósításokban viszont nullától (ekkor a tömb a megadottnál eggyel több elemet tartalmazott), vagy az 'OPTION BASE {0|1}' utasítással volt beállítható a kezdőindex.
Sorszámozás A korai BASIC változatokban kötelező volt a sorok számozása. Minden programsor elején egy sorszám állt. Ennek több oka volt:
Az ugrásoknál (GOTO, GOSUB) sorszámra hivatkozva lehetett csak megadni, hova ugorjon a vezérlés, a nyelv kezdeti változatai nem ismerték a címkéket. A kezdetleges fejlesztőkörnyezeteknél a sorszámról döntötte el az értelmező, melyik programsort írta be a felhasználó. Ha például a 30-as sor után írta be a 20-ast, akkor az sorrendben a 30-as elé került futtatáskor. A hibaüzeneteket is a sorszámot kiírva adták meg az interpreterek.
A sorszámozás hátránya a nehézkes bővíthetőség volt: ha a sorokat 10-esével számoztuk, akkor a 20-as és 30-as sor közé csak 9 sort szúrhattunk be. Emiatt a nyelvből lassan eltűntek a sorszámok, bár sokáig lehetett használni őket a visszafelé kompatibilitás megőrzése miatt. Microsoft vonalon az 1998-ban megjelent Visual Basic 6 volt az utolsó nyelv, ami még támogatta a használatukat. A feltétel nélküli ugrásokhoz a nyelv címkéket használ, amik sor elején álló, kettőspontra végződő azonosítónevek. A címkéket nem kell deklarálni.
Példa sorszámos ugrásra: 10 PRINT "Ez a szöveg ismétlődni fog!" 20 GOTO 10 Példa a címke használatára
eleje: PRINT "Ez a szöveg ismétlődni fog!" GOTO eleje
Hello World Az interpretált BASIC parancsként tudja futtatni a "PRINT" (írd ki) utasítást: PRINT "Hello World!" Megj.: A PRINT sok nyelvjárásban rövidíthető kérdőjellel: ? "Hello World!"
Programba illesztve (klasszikus változat, sorszámok használatával): 10 PRINT "Hello World!" 20 END Megjegyzés: Az "END" (vége) utasítás opcionális, a programfutás az utolsó sornál mindenképp véget ér.
Futtatása: RUN
Példaprogramok Példa 1:Strukturálatlan, eredeti BASIC(Applesoft BASIC nyelv) Példa 2:Modern Strukturált nyelv(például QBASIC programnyelv) 10 INPUT "Kérem adja meg a nevét: "; U$ 20 PRINT "Üdvözlöm "; U$ 25 REM 30 INPUT "Hány csillagot szeretne? "; N 35 S$ = "" 40 FOR I = 1 TO N 50 S$ = S$ + "*" 55 NEXT I 60 PRINT S$ 65 REM 70 INPUT "Kér még csillagot? "; A$ 80 IF LEN(A$) = 0 GOTO 70 90 A$ = LEFT$(A$, 1) 100 IF (A$ = "i") OR (A$ = "I") THEN GOTO 30 110 PRINT "Viszontlátásra! "; 120 FOR I = 1 TO 200 130 PRINT U$; " "; 140 NEXT I 150 PRINT INPUT "Kérem adja meg a nevét: "; UserName$ PRINT "Üdvözlöm "; UserName$ DO INPUT "Hány csillagot szeretne?"; NumStars Stars$ = "" Stars$ = REPEAT$("*", NumStars) ' <- ANSI BASIC ''--or--'' Stars$ = STRING$(NumStars, "*") ' <- MS BASIC PRINT Stars$ DO INPUT "Kér még csillagot? "; Answer$ LOOP UNTIL Answer$ <> "" Answer$ = LEFT$(Answer$, 1); LOOP WHILE UCASE$(Answer$) = "Y" PRINT "Viszontlátásra! "; FOR I = 1 TO 200 PRINT UserName$; " "; NEXT I PRINT
Nyelvi változatok Zárójelben a program futtatókörnyezete található.
Altair BASIC (MITS Altair, S-100; Microsoft első terméke) Amiga BASIC (Commodore Amiga) AMOS BASIC (Commodore Amiga) Apple Business BASIC (Apple ///) Applesoft BASIC (Apple II) ASIC programozási nyelv (MS-DOS) Atari 2600 Basic Programming (Atari 2600 video játék konzol) Atari BASIC (aka Sheperdson BASIC) (Atari 8 bites család) Atari Microsoft BASIC II (Atari 8 bites család) B32 Business Basic (Data General Eclipse MV, UNIX, MS-DOS) BASCOM (MCS Electronics) (Atmel AVR 8 bites mikrovezérlő családhoz) (Intel 8051-es 8 bites mikrovezérlő családhoz) BASIC09 (OS-9 és OS-9 68K, a Motorola 6809 és 68K processzoron, külön külön) Microsoft BASICA interpreter (Advanced BASIC, IBM PC korai változatán ROM-ba égetve) (Lemezzel ellátott gépeken a PC-DOS része) BASIC A Plus+ (Atari 8-bit család) BASIC-E programnyelv (aka 'submarine BASIC') (CP/M) Basic Plus (Digital Equipment Corporation gyártmány a RSTS/E OS, PDP-11 processzoron) BASIC XE programnyelv (Atari 130XE) BBC BASIC (Acorn/BBC Micro, RISC OS, Tiki 100, Cambridge Z88, CP/M, MS-DOS) Blitz BASIC & Blitz3D & BlitzMAX & BlitzPLUS (Win32, Commodore Amiga) Business Basic Bxbasm (Win32, open source, native compile) Bywater BASIC (aka bwBASIC) (MS-DOS, POSIX) Caché Basic (Caché Database egyik parancsleíró nyelve a kettőből) CBASIC programnyelv (BASIC-E leszármazottja) (CP/M, MS-DOS) Chipmunk Basic programnyelv (Apple Macintosh, CLI port Win32 részére, GNU/Linux; szabad szoftver) Color BASIC programnyelv (Tandy Radio Shack TRS-80 Color Computer, aka CoCo) Commodore BASIC (Commodore 8 bites család) DarkBASIC & DarkBASIC Professional Dartmouth BASIC (lásd még: True BASIC) Data General Business Basic (Data General Nova és későbbi DG miniszámítógépek) Ethos Game Basic (MS Windows) Extended Color BASIC (TRS-80 Color Computer) FutureBASIC (Apple Macintosh) Gambas (GNU/Linux) (Visual Basic-hez hasonló) geoBASIC (GEOS Commodore 64 számítógépen) GeoBASIC (Leica) (Leica TPS 1000/1100 vizsgálati állomásokon) Gnome Basic (GNU/Linux) (Visual Basic klón) GFA BASIC (Commodore Amiga, Atari ST) Microsoft GW-BASIC interpreter (MS-DOS) (BASICA compatibilis, IBM ROM routinoktól független) Hbasic (GNU/Linux) (Visual Basic-hez hasonló) HotPaw Basic programnyel (aka yBasic, nee cbasPad Pro) (PalmOS) IBasic (MS Windows) Integer BASIC (Apple II) IS-BASIC (Enterprise Computers: Enterprise 64, Enterprise 128) Liberty BASIC programnyelv (MS Windows) Locomotive BASIC (Amstrad CPC) LotusScript (Lotus Notes) MAI Basic Four Business Basic (többféle miniszámítógép) Mallard BASIC programnyelv (Amstrad PCW, CP/M on ZX Spectrum +3) MapBasic (MS Windows, MapInfo Professional) Microsoft BASIC (Microsoft BASIC variációk) (különféle mikroszámítógépeken) Microsoft MBASIC programnyelv (CP/M operációs rendszer alatt) MSX BASIC (MSX) Northstar BASIC (Processor Technology, Northstar, később átdolgozva x86 platformra Bazic '86 néven) NSBasic (Windows CE rendszer alatt) Phoenix Object Basic programnyelv (GNU/Linux) PowerBASIC (Turbo BASIC leszármazottja) (MSDOS, Win32) PureBasic (Win32, GNU/Linux és Commodore Amiga) QBASIC programnyelv (MS-DOS) Microsoft QuickBASIC fordító (MS-DOS) RapidQ (keresztplatform, szabad szoftver) REALbasic (Apple Macintosh, Win32, Linux) Revelation BASIC programnyelv (MS-DOS) SAM Basic programnyelv (SAM Coupé) ScriptBasic (Win32 and GNU/Linux) Sharp BASIC (Sharp zsebszámítógép) Sinclair BASIC (ZX80, ZX81/TS1000, ZX Spectrum) Sinclair Spectrum Beta BASIC (ZX Spectrum) SmallBASIC (GNU/Linux, MS-DOS, Win32, PalmOS; GPL) SmartBASIC (Coleco Adam) ST BASIC (Atari ST) StarOffice Basic (aka StarBasic) (OpenOffice, StarOffice) STOS BASIC (Atari ST) SuperBasic (Sinclair QL) THEOS Multi-User Basic TI BASIC programnyelv (Texas Instruments programozható kalkulátorok) TI BASIC (TI 99/4A) (Texas Instruments TI 99/4A) TI Extended BASIC programnyelv (ditto) Tiny BASIC (korai S-100 gépek) TRS-80 Level I BASIC programnyelv (TRS-80) (TinyBASIC alapú) TRS-80 Level II BASIC programnyelv (TRS-80) True BASIC (MS-DOS, MS Windows, Apple Macintosh) Turbo BASIC (BASIC/Z utód) VBScript (MS ASP, MS Windows with WSH) Visual Basic (MS Windows) Visual Basic .NET (MS Windows)