Sigles de deux caractères Sigles de trois caractères Sigles de quatre caractères > Sigles de cinq caractères Sigles de six caractères Sigles de sept caractères Sigles de huit caractères

En programmation, le BASIC (acronyme pour Beginner's All-purpose Symbolic Instruction Code, littéralement « Code d'instruction symbolique multi-usages du débutant »), est une famille de langages de programmation de haut niveau ayant pour but la facilité d'utilisation.

Buts

Le langage BASIC a été conçu en 19** par John George Kemeny (1926-1993) et Thomas Eugene Kurtz (1928-) au « Dartmouth College » pour permettre aux étudiants des filières autre que scientifiques d'utiliser des ordinateurs. Les langages de programmation de l'époque étaient en effet plus adaptés à la carte perforée qu'aux terminaux interactifs. Même le Fortran II, peu évolué bien que déjà complexe, était inadapté aux calculs matriciels dont on faisait déjà usage en sciences humaines. Non interactifs, ces langages exigeaient qu'un programme ne comporte pas une seule erreur de syntaxe pour être exécuté.

BASIC se voulut interactif et simple : ses sept instructions devaient pouvoir être enseignées en une demi-journée, et des opérations matricielles être exécutables en mode calcul de bureau. Un programme devait pouvoir s'exécuter au moins jusqu'à ce que soit rencontrée une première erreur, facilitant ainsi l'apprentissage du langage.

L'acronyme BASIC est lié au titre d'un article de Kurtz non publié et n'a pas de rapport avec les séries intitulées « Anglais basic » de Charles Kay Ogden. Les concepteurs du langage le destinaient au domaine public, ce qui favorisa sa diffusion, et l'écriture d'un interpréteur de BASIC faisait partie des projets classiques donnés aux étudiants en informatique dans le monde entier.

Le BASIC équipa dès le milieu des années 1970 presque tous les micro-ordinateurs du moment (Olivetti P6060, Tektronix 4051, IBM 5100, Commodore PET, etc.). Dans les années 1980, la plupart des micro-ordinateurs étaient fournis avec un interprète BASIC, parfois en ROM, et quelques calculatrices programmables en furent même dotées. Le premier IBM PC pouvait démarrer sans disquette et donnait alors la main à un BASIC rudimentaire en mémoire morte.

Les huit principes de conception du BASIC étaient :

être facile à apprendre pour un débutant ;

être généraliste, donc traiter aussi bien les matrices de nombres que les chaînes de caractères ;

autoriser l'ajout de fonctionnalités pour les experts (tout en gardant le langage simple pour les débutants) ;

être interactif, et entre autres permettre d'interrompre un programme pour examiner ses variables, en modifier quelques instructions, et reprendre ensuite son exécuion ;

fournir des messages d'erreur clairs et conviviaux ;

avoir un délai de réaction faible pour les petits programmes ;

ne pas nécessiter de connaissances sur le matériel de l'ordinateur ;

isoler l'utilisateur du système d'exploitation s'il y en avait un.

Histoire

Fichier Basic, et exécutions sur un DVK (en).

Le BASIC est peut-être le langage de programmation le plus connu. La forme originelle du langage s'inspire du Fortran, avec des ajouts pour le rendre interactif et capable de traiter en mode calcul de bureau des opérations matricielles, notamment multiplication et inversion. BASIC est souvent interprété, mais rien ne l'empêche d'être compilé là où l'interactivité avec le programmeur n'était plus nécessaire, par exemple packages de gestion. Malgré sa normalisation, plusieurs dialectes sont apparus au cours des années, partis de la même base, et proposant des améliorations diverses, par exemple dans le domaine des interfaces graphiques ou de l'orienté objet. La référence sur PC (MS-DOS) a été le GW-BASIC puis quelque temps le QuickBasic.

La première version du BASIC a été développée sur un ordinateur central temps réel appelé GE-256 (General Electric), qui était un GE-225 avec une GE DataNet-30. Cet ordinateur 20 bits, conçu en 1959 au sein du département d'informatique industrielle de la société General Electric par Arnold Spielberg, père de Steven Spielberg, occupait une pièce entière, embarquait 10 000 transistors et 20 000 diodes. Les données étaient conservées sur des bandes magnétiques enroulées sur des bobines, des cartes perforées ou des bandes de papier. Vendu 250 000 dollars à l’époque, le GE-225 a été un succès commercial, malgré la désapprobation du directeur général de la société qui le produisait. BASIC était le premier langage spécialement conçu pour être utilisé sur des systèmes interactifs.

Les premières versions de BASIC étaient utilisées sur des ordinateurs en temps partagé. L’interprétation était plus commode que la compilation, car les modifications ne portaient souvent que sur quelques lignes entre deux passages successifs.

Les constructeurs des premiers ordinateurs individuels avec clavier ont eu besoin d'inclure un outil permettant aux utilisateurs d'écrire des logiciels pour leur matériel. L'un des premiers, TRW, avait créé son propre langage pour ses terminaux programmables Datapoint, mais l'abondance d'étudiants connaissant BASIC le conduisit à porter ce langage sur des machines comme son 2200. Une version interprétée pouvait sans difficulté tenir en mémoire morte (ROM) ou vive. BASIC avait en 1970 un concurrent, le langage FOCAL, mais celui-ci était propre à DEC et fut vite marginalisé, comme le sera le HPL de Hewlett-Packard six ans plus tard.

BASIC offrait aussi quelques commandes comme old, new, list et quelques autres déjà définies à l'intérieur même du langage, lui conférant ses capacités interactives.

Les instructions scalaires commençaient par LET (LET A=3) et les matricielles par MAT (MAT C = A+B). Très vite, le LET deviendra facultatif pour alléger l'écriture des programmes.

Chaque instruction était précédée d'un nombre, en général attribué de 10 en 10, qui permettait de remplacer une instruction ou d'en insérer entre d'autres sans avoir à maîtriser un complexe éditeur de texte en mode machine à écrire.

Les premiers ordinateurs individuels possédaient presque tous un interpréteur BASIC en mémoire morte (TI-99/4A, **, TRS-80, Apple II, etc.). Hewlett-Packard laissait le choix sur son 9825 entre un BASIC standard et son langage maison HPL plus puissant, mais moins standard. Ces langages étaient sur cartouche ROM amovible.

En 1968, un article d'Edsger Dijkstra devenu très populaire avait insisté sur la nocivité de l'instruction « goto » en matière de qualité du code, et donc la productivité du programmeur. Cette critique s'appliquait alors à la plupart des langages, dont les dialectes du BASIC. Dix ans plus tard, presque tous les langages avaient pris cette critique en compte y compris BASIC. La popularité du BASIC, langage de programmation grand public par excellence, fit dire à certains que ce langage a donné naissance à plus de mauvais programmes qu'aucun autre langage. Olivier Lecarme, professeur à l'Université Laval, affirmait à l'AFCET : « BASIC programming cannot teach you any kind of programming, not even basic programming ». De fait, privilégiant l'action plutôt que la méthode, ce langage aux contrôles sommaires ne convient qu'à la « petite programmation » (moins de 500 lignes).

Les versions les plus répandues ont été les interpréteurs conçus par Microsoft, qui pratiquait une politique de prix modérés et avait fini par s'imposer comme la référence : quelles que fussent les machines source et cible, on savait qu'un programme écrit en BASIC Microsoft tournerait sur un autre BASIC Microsoft.

En 1977 Microsoft avait sorti l'Altair Basic (adaptation du Basic par Bill Gates et Paul Allen) pour l'Altair 8800 du constructeur MITS. C'était son premier logiciel. En 1979 Microsoft obtint d'IBM la commercialisation de son interprète BASIC avec les futurs IBM PC et compatible PC. Cette version était incluse dans la puce ROM des PCs, et se lançait au démarrage en l'absence de système d'exploitation. Plus tard, Microsoft a vendu différentes versions du BASIC pour DOS, dont Basica, GW-BASIC, QuickBasic et Visual Basic pour MS-DOS. Microsoft Windows 95 et Windows 98 incluaient un interpréteur QBasic à installer à partir du CD-ROM et Windows 98 incluait un interprète VBScript. Visual Basic for Applications a été ajouté dans les produits Microsoft Office en 1997.

À la même époque, le Basic sur Apple II ne connaissait que les nombres entiers ; il fallut attendre l'Apple II+ pour le traitement des réels.

Le compilateur Waterloo BASIC fut l'un des premiers logiciels commercialisés par Watcom : il avait été programmé entre 1978 et 1979 pour l’IBM Series/1, un PC 16 bits. En 1979, le compilateur a été porté pour VM/CMS tournant sur les IBM 370, 3030 et 4300, et un accord avec IBM a permis sa mise sur le marché. Il y eut plusieurs mises à jour de 1980 à 1983 ainsi qu'une version portée sur l’interpréteur de commandes MVS/TSO et sur VM/CMS.

Borland a publié son compilateur Turbo Basic 1.0 en 1985. Les versions suivantes sont encore vendues sous le nom de PowerBasic par une autre compagnie. Il existe toujours une version pour MS-DOS.

La nécessité d'enseigner un langage de programmation davantage structuré avait donné naissance au langage Pascal en 1972. Ce langage, en particulier grâce au compilateur Turbo Pascal de la société Borland, bien plus rapide que n'importe quel interprète BASIC de l'époque, remporta un énorme succès au cours des années 1980, et marqua un début de déclin de la popularité du BASIC dans le grand public.

Syntaxe

La syntaxe vraiment minimale du BASIC est seulement composée de l'instruction d'affectation par le signe "=" (devant autrefois être précédée du mot-clé LET), PRINT (affichage à l'écran), IF-THEN-ELSE (exécution conditionnelle) et GOTO (saut vers une zone du programme). Un interprète qui exécute des programmes avec cette syntaxe minimale n'a pas besoin d'une pile. Nombre des premières implémentations sur micro-ordinateur n'eurent que ces instructions, les programmes n'étaient donc pas structurés. Si on ajoute une pile, l'instruction GOSUB (saut vers une séquence servant de sous-programme et terminée par RETURN) fut rapidement ajoutée.

le développement de formes IF à deux branches, la multiplication des formes itératives, et l'obligation d'expliciter les étiquettes pour les branchements résiduels ;

l'introduction de fonctions paramétrables, d'abord d'une ligne, puis de plusieurs lignes, puis récursives.

Procédures

Le BASIC n'a généralement pas de bibliothèque externe standard comme d'autres langages, le langage C par exemple. Au lieu de cela, l'interprète ou le compilateur contiennent une bibliothèque intégrée étendue de procédures intrinsèques. Ces procédures incluent plus d'outils que ce dont le programmeur a besoin pour apprendre la programmation et écrire de simples applications, dont des fonctions mathématiques, des fonctions de traitement des chaînes de caractères, d'entrée-sortie console, de graphisme et de manipulation de fichiers. Le QuickBasic permet d'inclure des bibliothèques écrites dans ce langage (QLB) ou en d'autres langages (LIB). Certains dialectes BASIC ne permettent pas aux programmeurs d'écrire leurs propres procédures. À cause de cela, les programmeurs sont obligés d'écrire leurs programmes avec une importante utilisation de goto et de gosub : cela fait qu'il est très difficile de suivre un tel code source, appelé couramment un « code spaghetti ». Beaucoup de versions du BASIC comme le QuickBasic de Microsoft ont ajouté un support des sous-routines et des fonctions (avec support de la récursivité). Il fait la distinction entre une procédure qui ne retourne jamais de valeur (appelée sous-routine ou sub) et une procédure qui en renvoie (appelée fonction). Certains langages ne font pas cette distinction et considèrent tout comme une fonction dont certaines renvoient une valeur « vide ». Le BASIC est bien connu pour ses fonctions de manipulations de chaînes de caractères. Les premiers dialectes avaient déjà un ensemble de fonctions basiques (left$, mid$, right$) pour les traiter simplement. Comme elles sont souvent utilisées dans les applications de tous les jours, cela est un avantage considérable.

Types de données

Chaque dialecte BASIC de base gère les données de type entier et chaîne de caractères. Normalement, ils n'ont pas besoin de les déclarer comme telles, mais les dialectes modernes ont l'option de forcer le type (typiquement en utilisant une directive appelée « Option Explicit »). Les types de données modernes supportés par le BASIC incluent : booléens, entiers signés sur 16 bits, entiers signés sur 32 bits, chaînes de caractères, nombres décimaux. Certains dialectes comme Visual Basic ont plus de types de données intrinsèques. De plus, certains dialectes permettent à l'utilisateur de définir ses propres types, appelés types définis par l'utilisateur, et qui sont en fait des structures, c'est-à-dire une simple variable contenant plusieurs champs.

Disponibilité et variantes

la série CPC de Amstrad ;

la série MO et TO de la marque Thomson ;

les ordinateurs au standard MSX (1, 2, 2+, Turbo R) utilisaient un Basic dérivé du GW-Basic, la gestion de la couleur et des sprites s'apparentait à celle des TI-99, le processeur graphique utilisé sur ces différentes machines étaient le TMS9929, un processeur Texas Instruments

les modèles de la marque Commodore ;

le DAI Imagination machine ;

les Apple I, II, III et variantes utilisaient un Basic maison mais pouvaient aussi, sur les modèles équipés d'une carte CP/M utiliser la version Basic du CP/M proche du GW-Basic;

le TI-99/4A de Texas Instruments ;

certaines calculatrices Casio et Texas Instruments ;

les Sinclair ZX-81 et ZX-Spectrum ;

le Tektronix 4051 (BASIC graphique sur écran rémanent) ;

l'Olivetti P6060 mais aussi M30 et M40 (partie intégrante de l'OS appelé ESE) ;

l'Olivetti M10 (ordinateur ayant 24 Ko ou 32 Ko de RAM non volatile avec BASIC en ROM, et pas de disque dur ni de disquettes) ;

Exelvision avec l'EXL 100 et le module EXELBASIC. Le Basic de l'EXL100 était un dérivé de l'Extended Basic du TI-99, les concepteurs de cette machines étant des transfuges de Texas Instruments ;

l'IBM PC et Compatible PC dont les premiers modèles avaient un BASIC limité en ROM. Le Basic était fourni sur les disquettes système MS-DOS ou PC-DOS versions 1.0 à 4.0. Pour les IBM PC, le Basic s'appelait Basica alors que sur les compatibles PC il se nommait GW-Basic

Exemples

en général, l'interpréteur est insensible à la casse ; les instructions étaient tapées en majuscules sur les machines faisant la distinction entre majuscules et minuscules ;

un nom de variable suivi d'un signe dollar indique qu'il s'agit d'une chaîne de caractères (NOM$, ETOILE$, S$) ; une variable sans signe dollar indique un entier ou un nombre décimal (S, I) ;

INPUT permet l'affichage d'un texte et une saisie du clavier ; PRINT permet un affichage à l'écran ;

parfois l'instruction LET est optionnelle, ainsi, LET ETOILE$ = ETOILE$ + "*" peut s'écrire simplement ETOILE$ = ETOILE$ + "*" (le signe égal sert à la fois aux affectations de variables et aux tests d'égalité) ;

FOR-NEXT est une boucle ;

IF-THEN est une instruction conditionnelle ; OR est l'opérateur logique « Ou » ;

LEN est une fonction renvoyant la longueur de la chaîne de caractères, LEFT$(ETOILE$, n) est une fonction renvoyant une sous-chaîne composée de n caractères situés à gauche de la chaîne ETOILE$ ; + est l'opérateur de concaténation (c'est aussi l'opérateur de l'addition).

Documents définissant le BASIC

Le manuel du BASIC conçu au Dartmouth College

ANSI Standard for Minimal Basic (ANSI X3.60-1978 "FOR MINIMAL BASIC")

ISO Standard for Minimal Basic (ISO/CEI 6373:1984 "DATA PROCESSING - PROGRAMMING LANGUAGES - MINIMAL BASIC")

ANSI X3.113-1987 Programming Languages - Full BASIC

ANSI X3.113a-1989 Programming Languages - Modules and Individual Character Input for Full BASIC

ISO Standard for Full Basic (ISO/CEI 10279:1991 "INFORMATION TECHNOLOGY - PROGRAMMING LANGUAGES - FULL BASIC")

ANSI Addendum Defining Modules (X3.113 INTERPRETATIONS-1992 "BASIC TECHNICAL INFORMATION BULLETIN # 1 INTERPRETATIONS OF ANSI 03.113-1987")

ISO Addendum Defining Modules (ISO/CEI 10279:1991/ Amd 1:1994 "MODULES AND SINGLE CHARACTER INPUT ENHANCEMENT")

Standard ECMA-55, Minimal BASIC (janvier 1978)

Standard ECMA-116, BASIC (juin 1986)

BASIC（来自英语：Beginner's All-purpose Symbolic Instruction Code的缩写），又译培基，一种直译式进程设计语言。名称字面为意思“初学者的全方位符式指令代码”，设计给初学者使用的编程语言，在完成编写后不须经由编译及链接等手续，经过解释器即可运行，但如果需要单独运行时仍然需要将其创建成运行档。

BASIC的历史

让初学者容易使用。

成为通用编程语言。

允许为熟练者添加高级的功能（与此同时对初学者保持简单）。

成为交互式语言。

提供清楚的和友好的错误信息。

对小型的进程反应迅速。

不需要对硬件的了解。

将用户和操作系统隔离。

BASIC语言的种类

以下是同样的运行结果，但用不同时期的BASIC的方式所写的范例。 行号类型（非结构化） 这是第一代的BASIC，例如早期BASICA、GW-BASIC……等，BASIC解释器。这类的BASIC程序的特征，就是每一行的代码前面都有一个数字作为「行号」。由于这种类型的BASIC程序的写法，很容易滥用GOTO的跳跃指令，以及代码没有办法使用到缩进去区分区段，因此很容易导致面条式代码。 10INPUT"What is your name: ",U$ 20PRINT"Hello ";U$ 30INPUT"How many stars do you want: ",N 40S$="" 50FORI=1TON 60S$=S$+"*" 70NEXTI 80PRINTS$ 90INPUT"Do you want more stars? ",A$ 100IFLEN(A$)=0THENGOTO90 110A$=LEFT$(A$,1) 120IFA$="Y"ORA$="y"THENGOTO30 130PRINT"Goodbye ";U$ 140END 无行号类型（结构化） 这是第二代的BASIC，例如QuickBASIC、PowerBASIC。这时期，同时有功能相近的解释器与编译器的版本出现。这类的BASIC程序的特征，是不使用行号，改使用标签作为跳跃点（仍有GOTO指令，但已可使用其他写法可完全避开使用GOTO），与使用函数或副程序的方式，以及可使用缩进，将程序结构化。 INPUT"What is your name: ",UserName$ PRINT"Hello ";UserName$ DO INPUT"How many stars do you want: ",NumStars Stars$=STRING$(NumStars,"*") PRINTStars$ DO INPUT"Do you want more stars? ",Answer$ LOOPUNTILAnswer$<>"" Answer$=LEFT$(Answer$,1) LOOPWHILEUCASE$(Answer$)="Y" PRINT"Goodbye ";UserName$ 面向对象化 这是第三代的BASIC，例如Visual Basic、REALbasic、StarOffice Basic。这类的BASIC程序的特征，是导入类别（Class）的应用，使用面向对象的继承与代码封装的写法。通常也使用「事件驱动」的写法，虽然下面这个Visual Basic .NET的范例并不是用到「事件驱动」。 Public Class StarsProgram Public Shared Sub Main() Dim UserName, Answer, stars As String, NumStars As Integer Console.Write("What is your name: ") UserName = Console.ReadLine() Console.WriteLine("Hello {0}", UserName) Do Console.Write("How many stars do you want: ") NumStars = CInt(Console.ReadLine()) stars = New String("*", NumStars) Console.WriteLine(stars) Do Console.Write("Do you want more stars? ") Answer = Console.ReadLine() Loop Until Answer <> "" Answer = Answer.Substring(0, 1) Loop While Answer.ToUpper() = "Y" Console.WriteLine("Goodbye {0}", UserName) End Sub End Class

指令

Goto指令 Goto是一种程序运行无条件跳跃的指令，在有行号的BASIC里后面是接要跳跃目的的行号。在无行号的BASIC里后面则是接要跳跃目的的标记名称。 END指令 用于终止一个BASIC进程的运行。 它的效果有些类似C语言里的exit函数。所不同的是END不带有任何的参数，仅仅是一条指令。需要注意的是，在Visual Basic中end（虽然不区分大小写但多习惯用小写）指令用于强制退出整个进程，但并不能保证完整的释放进程所使用的资源。因此在退出之前最好先手动释放资源。