Section courante

A propos

Section administrative du site

 Langage  Elément  Tutoriel  Programmation  Extension  Emulateur  Annexe  Aide 
ABAP/4
Ada
Assembleur
Assembly & bytecode
ASP (Active Server Pages)
Basic
C
C++
C# (C Sharp)
Cobol
ColdFusion
Fortran
HTML
Java
JavaScript
LISP
Logo
LotusScript
Oberon
Pascal
Perl
PHP
PL/1
Prolog
Python
Rebol
REXX
Ruby
Rust
SAS
NoSQL
SQL
Swift
X++ (Axapta)
GNAT
SMALLAda
VHDL
Assembleur 370
Assembleur 1802
Assembleur 4004
Assembleur 6502
Assembleur 6800
Assembleur 68000
Assembleur 8080 et 8085
Assembleur 8089
Assembleur 80x86
Assembleur AGC4
Assembleur ARM
Assembleur DPS 8000
Assembleur i860
Assembleur Itanium
Assembleur MIPS
Assembleur PDP-11
Assembleur PowerPC
Assembleur RISC-V
Assembleur SPARC
Assembleur SuperH
Assembleur UNIVAC I
Assembleur VAX
Assembleur Z80
Assembleur Z8000
Assembleur z/Architecture
ASSEMBLER/MONITOR 64
Micol Assembler
GFA Assembler
A86
MASM (Macro Assembler)
TASM (Turbo Assembler)
CIL
Jasmin
LLVM
MSIL
Parrot
P-Code (PCode)
SWEET16
G-Pascal
ASP 1.0
ASP 2.0
ASP 3.0
ASP.NET
ASP.NET Core
ABasiC (Amiga)
Adam SmartBASIC
Altair BASIC
AmigaBASIC (Amiga)
AMOS Basic (Amiga)
Atari Basic (Atari 400, 600 XL, 800, 800XL)
Basic Apple II (Integer BASIC/APPLESOFT)
Basic Commodore 64 (CBM-BASIC)
Basic Commodore 128 (BASIC 7.0)
Basic Commodore VIC-20 (CBM-BASIC 2.0)
Basic Coco 1 (Color Basic)
Basic Coco 2 (Extended Color Basic)
Basic Coco 3 (Extended Color Basic 2.0)
BASICA (PC DOS)
Basic Pro
BBC BASIC
Blitz BASIC (Amiga)
DarkBASIC
Dartmouth BASIC
GFA-Basic (Atari ST/Amiga)
GWBASIC (MS-DOS)
Liberty BASIC
Locomotive BASIC (Amstrad CPC)
MSX-Basic
Omikron Basic (Atari ST)
Oric Extended Basic
Power Basic
Quick Basic/QBasic (MS-DOS)
Sinclair BASIC (ZX80, ZX81, ZX Spectrum)
ST BASIC (Atari ST)
Turbo Basic
Vintage BASIC
VBScript
Visual Basic (VB)
Visual Basic .NET (VB .NET)
Visual Basic pour DOS
Yabasic
BeckerBASIC
SIMONS' BASIC
Basic09 d'OS-9
Disk Extended Color Basic
Basic09 d'OS-9
Disk Extended Color Basic
Access
Excel
Visual Basic pour Windows
Visual Basic .NET pour Windows
C Shell Unix (csh)
C pour Amiga
C pour Atari ST
C pour DOS
C pour Falcon030
C pour GEMDOS (Atari ST)
C pour Linux
C pour PowerTV OS
C pour OS/2
C pour Unix
C pour Windows
Aztec C
CoCo-C
GNU C
HiSoft C
IBM C/2
Introl-C
Lattice C
Microsoft C
MinGW C
MSX-C
Open Watcom C
OS-9 C Compiler
Pure C
Quick C
Turbo C
HiSoft C for Atari ST
HiSoft C for CP/M (Amstrad CPC)
C++ pour OS/2
C++ pour Windows
Borland C++
C++Builder
IBM VisualAge C++
Intel C++
MinGW C++
Open Watcom C++
Symantec C++
Turbo C++
Visual C++
Visual C++ .NET
Watcom C++
Zortech C++
C# (C Sharp) pour Windows
Apple III Cobol
Microsoft Cobol
BlueDragon
Lucee
OpenBD
Railo
Smith Project
Microsoft Fortran
WATFOR-77
CSS
FBML
Open Graph
SVG
XML
XSL/XSLT
LESS
SASS
GCJ (GNU)
JSP
Jython
Visual J++
Node.js
TypeScript
AutoLISP
ACSLogo
LotusScript pour Windows
Amiga Oberon
Oberon .NET
Apple Pascal
Delphi/Kylix/Lazarus
Free Pascal
GNU Pascal
HighSpeed Pascal
IBM Personal Computer Pascal
Lisa Pascal
Maxon Pascal
MPW Pascal
OS-9 Pascal
OSS Personal Pascal
Pascal-86
Pascal du Cray Research
Pascal/VS
Pascal-XT
PURE Pascal
QuickPascal
RemObjets Chrome
Sun Pascal
THINK Pascal
Tiny Pascal (TRS-80)
Turbo Pascal
UCSD Pascal
VAX Pascal
Virtual Pascal
Turbo Pascal for CP/M-80
Turbo Pascal for DOS
Turbo Pascal for Macintosh
Turbo Pascal for Windows
CodeIgniter (Cadre d'application)
Drupal (Projet)
Joomla! (Projet)
Phalanger (PHP .NET)
phpBB (Projet)
Smarty (balise)
Twig (balise)
Symfony (Cadre d'application)
WordPress (Projet)
Zend (Cadre d'application)
PL360
PL/M-80
PL/M-86
Turbo Prolog
CPython
IronPython
Jython
PyPy
AREXX
Regina REXX
JMP
Btrieve
Cassandra
Clipper
CouchDB
dBASE
Hbase
Hypertable
MongoDB
Redis
Access
BigQuery
DB2
H2
Interbase
MySQL
Oracle
PostgreSQL
SAP HANA
SQL Server
Sybase
U-SQL
Introduction
Les remarques
Les opérateurs
Les instructions conditionnelles
Les instructions de boucle
Type de données élémentaires
Référence d'instructions et de fonctions
Déballage et branchement d'un Commodore 64
Mise en oeuvre
Écrire des programmes BASIC simples
Variables et opérateurs
Créer du son
Principes de base
Débuter avec le BASIC
Bonjour
BeckerBASIC
SIMONS' BASIC
C64 Forever
VICE
Référence des messages d'erreurs
RAM de Commodore 64
Codes d'affichage de la table de caractères du Commodore 64
Référence des codes de jetons d'instructions
Préface
Notes légal
Dictionnaire
Recherche

Écrire des programmes BASIC simples

Vous voudrez probablement utiliser votre micro-ordinateur Commodore 64 pour effectuer des tâches plus complexes utilisant plusieurs instructions. Lorsque vous combinez un certain nombre d'instructions dans un programme, vous pouvez utiliser toute la puissance de votre Commodore 64. Pour voir à quel point il est facile d'écrire votre premier programme sur Commodore 64, procédez comme suit :

Numéros de ligne

Nous avons déjà précédemment que les numéros de ligne indiquent à l'ordinateur que vous écrivez un programme. Ils indiquent également à l'ordinateur dans quel ordre vous voulez que les instructions de votre programme s'exécutent. Sans numéros de ligne pour indiquer à l'ordinateur quand suivre quelle instruction, l'ordinateur ne sait pas quoi faire en premier. Plus votre programme est long et complexe, plus il est important de se rappeler que l'ordinateur compte sur vous pour lui dire quand faire les choses, ainsi que quoi faire. Une bonne chose à ce sujet est que vous pouvez saisir la ligne 20 avant la ligne 10 car l'ordinateur vérifie simplement les numéros de ligne pour connaître l'ordre d'exécution du programme. L'ordinateur ne vérifie pas l'ordre dans lequel vos lignes apparaissent à l'écran. Un autre avantage des numéros de ligne est que vous pouvez utiliser le numéro pour faire référence à l'instruction sur la ligne. Lorsque vous souhaitez revenir en arrière et répéter l'exécution d'une instruction, il vous suffit de vous y référer par numéro de ligne dans une instruction GOTO, comme vous l'avez fait dans l'exemple ci-dessus.

L'instruction GOTO

Lorsque vous avez dit à l'ordinateur d'exécuter l'exemple de programme ci-dessus, le Commodore 64 a été affiché à plusieurs reprises au lieu d'une seule fois en raison de l'instruction GOTO à la ligne 20. L'instruction GOTO indique à l'ordinateur d'aller directement à une ligne spécifiée. Ensuite, l'ordinateur suit les instructions de la ligne spécifiée et passe à la ligne suivante. Vous pouvez utiliser une instruction GOTO pour dire à l'ordinateur de revenir à une ligne ayant déjà été exécutée. Ou GOTO peut dire à l'ordinateur de sauter en avant, même si cela signifie que certaines lignes du programme ne sont pas exécutées. Dans notre exemple, le programme PRINT le message de la ligne 10 et passe à la ligne 20. Là, l'instruction GOTO indique à l'ordinateur de revenir à la ligne 10 et de faire ce que la ligne 10 dit de faire. Ainsi, le programme affiche à nouveau le message à la ligne 10, puis passe à la ligne 20, renvoyant l'ordinateur à la ligne 10 et ainsi de suite. Cette répétition est appelée une boucle. Parce que l'exemple ne donne pas à l'ordinateur un moyen de sortir de la boucle, le cercle se répète sans fin. Vous devez arrêter le cycle en interrompant le programme avec la touche STOP. Il est préférable d'inclure une instruction dans votre programme terminant la boucle afin de ne pas avoir à utiliser la touche STOP.

Utilisation de la commande LIST

Maintenant que vous avez interrompu l'exécution de l'exemple de programme, tapez LIST et appuyez sur RETURN. Votre programme est maintenant affiché intact car il est toujours dans la mémoire de l'ordinateur, même si vous avez interrompu l'exécution du programme. La seule différence est que l'ordinateur a changé votre ? dans le mot PRINT. Cela n'affecte pas votre programme, c'est juste la façon dont l'ordinateur fait les choses. Lorsque vous utilisez la commande LIST, l'ordinateur affiche également les lignes du programme dans l'ordre numérique correct, même si vous avez entré les lignes dans le désordre. L'une des différences importantes entre l'écriture de programmes et la saisie de lignes uniques en mode immédiat / calculatrice est que vous perdez définitivement une instruction immédiate une fois que vous l'exécutez et effacez l'écran. Mais, jusqu'à ce que vous démarriez un nouveau programme, vous pouvez toujours le récupérer en tapant simplement LIST. À partir de là, vous pouvez modifier le programme, le SAVE ou le RUN.

Conseils d'édition

Lorsque vous faites une erreur dans une ligne que vous avez saisie, ou lorsque vous souhaitez simplement modifier une ligne, le Commodore 64 vous offre un certain nombre d'options d'édition.

Lorsque vous avez terminé l'édition, vous pouvez vérifier à nouveau votre programme pour vérifier les modifications en tapant la commande LIST. N'oubliez pas que LIST met également les lignes dans l'ordre numérique si vous les avez saisies dans le désordre. Essayez de modifier notre exemple de programme en ajoutant un point-virgule à la fin de la ligne et en omettant le Commodore 64. Une fois les modifications terminées, assurez-vous de déplacer le curseur au-delà de la ligne 20 avant d'exécuter le programme. Voici comment le programme fonctionne maintenant :

  1. LIST
  2. 10 PRINT "GLADIR.COM";
  3. 20 GOTO 10
  4. RUN

on obtiendra le résultat suivant :

GLADIR.COM GLADIR.COM GLADIR.COM GLADIR.COM
GLADIR.COM GLADIR.COM GLADIR.COM GLADIR.COM
BREAK IN 10
READY

Comment utiliser les variables

Une variable est un symbole représentant une valeur. Parfois, la valeur d'une variable est inconnue avant d'exécuter un programme. L'un des objectifs d'un programme peut être de trouver une ou plusieurs valeurs pour une variable. Regardez cette ligne d'un programme :

  1. 20 LET X = 28 + Y

Le signe «=» signifie «devenir» ou «prendre la valeur de». L'instruction LET est facultative et peut être omise. Dans cette équation, X et Y sont des variables. Supposons que X représente le nombre de jours dans un mois. L'une des meilleures choses à propos d'une variable est que vous pouvez la réutiliser dans un programme, afin que X puisse représenter les jours de tous les mois, pas seulement un mois. C'est là que Y entre en jeu. Tous les mois ont 28 jours, donc Y représente les jours de plus de 28. Il y a un programme donnant des valeurs à ces deux variables. Le plus important maintenant est de comprendre le fonctionnement des variables, car les variables vous permettent d'effectuer des tâches complexes avec votre micro-ordinateur. Les variables vous permettent également d'écrire des programmes très réutilisables. Imaginez que votre micro-ordinateur contienne un tas de petites fentes, comme une banque de boîtes aux lettres. Lorsque vous écrivez un programme, vous pouvez utiliser certains de ces emplacements pour contenir des valeurs. Tout ce que vous faites est de donner un nom aux fentes dont vous avez besoin, et pendant le programme, vous pouvez mettre des valeurs dans chaque fente en utilisant le nom du fente. Par exemple, dans l'équation ci-dessus, nous avons utilisé deux emplacements en nommant un X et un Y. Au début d'un programme, ces emplacements ont des noms, mais ils sont vides. Voici ce qui se passe lorsque vous mettez une valeur dans l'emplacement de Y :

X Y      
  3      

Maintenant, la variable Y a la valeur 3. Vous pouvez donner cette valeur à Y simplement en écrivant cette instruction simple :

  1. 10 Y = 3

Puisque X est égal à 28 plus Y, lorsque vous exécutez, l'emplacement du programme X obtient également une valeur.

X Y      
31 3      

Voici à quoi ressemble le programme :

  1. 10 Y = 3
  2. 20 X = 28 + Y
  3. 30 PRINT "LE NOMBRE DE JOUR DANS MAI EST ";X
  4. RUN

Il affichera le message suivant :

LE NOMBRE DE JOUR DANS MAI EST 31

Voici un autre programme utilisant des variables :

  1. 10 X% = 15
  2. 20 X = 23.5
  3. 30 X$ = "TOTAL:"
  4. 40 Y = X% + X
  5. 50 PRINT X$;Y

Lorsque vous exécutez le programme, les emplacements imaginaires ressemblent à ceci après l'exécution de la ligne 30 :

X% X X$ Y  
15 23.5 TOTAL:      

À la fin du programme, Y a la valeur : 38,5. L'exemple ci-dessus utilise les trois types de variables :

Type Symbole Description Exemples Exemple de valeurs
Entier % Nombres entiers X%, A1% 15,102,3
Texte $ Chaîne de caractères X$, AB$ "TOTAL:", "JOUR 1"
Point flottant   Réel X, AB 23.5, 12, 1.3E + 2

Assurez-vous d'utiliser les bons types de variables dans vos programmes. Si vous essayez de faire quelque chose comme assigner une chaîne de texte à une variable entière, votre programme ne fonctionnera pas. Il y a quelques autres choses à garder à l'esprit lorsque vous attribuez des noms à des variables :

Voici un autre exemple de programme montrant comment utiliser les variables :

  1. NEW
  2. 10 X = 1.05
  3. 20 Y = 300
  4. 30 Z = X * Y
  5. 40 PRINT "SIEGES DISPONIBLES:";Y
  6. 50 PRINT "BILLETS DISPONIBLES:";Z
  7. 60 Y = Y + 1
  8. 70 PRINT "POINT SUR RESERVATION:";Y
  9. RUN

On obtiendra le résultat suivant :

SIEGES DISPONIBLES: 300
BILLETS DISPONIBLES: 315
POINT SUR RESERVATION: 301

Les lignes (10-30) attribuent des noms de variables. Les lignes 40 et 50 PRINT un message et la valeur actuelle des variables Y et Z. Notez qu'à la ligne 40, la valeur de Y est 300. La ligne 60 donne une nouvelle valeur à Y, et cette nouvelle valeur est PRINT à la ligne 70. La ligne 60 montre qu'une variable peut avoir plus d'une valeur dans un programme. La ligne 60 montre également une autre des fonctionnalités puissantes des variables : vous pouvez rendre une variable égale à elle-même et à une autre valeur. Cela n'est pas autorisé dans l'algèbre régulière, mais ce type de déclaration est couramment utilisé en programmation. Cela signifie : prenez la valeur actuelle d'une variable, combinez-la avec une autre valeur et remplacez la première valeur de la variable par cette nouvelle valeur. Vous pouvez également utiliser des instructions comme celles-ci :

  1. Y = Y - 1
  2. Y = Y + X
  3. Y = Y / 2
  4. Y = Y * (X + 2)

Utilisation des boucles FOR/NEXT

Lors de l'explication de l'instruction GOTO, vous vous en souvenez, les boucles sont des exécutions répétées d'une ou plusieurs lignes dans un programme. L'instruction FOR/NEXT vous permet de créer des boucles très utiles contrôlant le nombre d'exécutions d'un segment d'un programme. L'instruction FOR définit une limite sur le nombre d'exécutions de la boucle en affectant une intervalle de valeurs à une variable. Par exemple :

  1. FOR COMPTEUR=1 TO 4     

L'instruction NEXT marque la fin d'une boucle FOR/NEXT. Lorsque le programme atteint une instruction NEXT, le micro-ordinateur vérifie l'instruction FOR pour voir si la limite de la boucle a été atteinte. Si la limite n'a pas été atteinte, la boucle continue et la variable dans l'instruction FOR est incrémentée de un. Par exemple, si vous ajoutez une boucle FOR/NEXT au programme au début de la page, voici ce qui se passe :

  1. 10 FOR I=1 TO 4
  2. 20 PRINT "GLADIR.COM !"
  3. 30 NEXT I
  4. RUN

On obtiendra le résultat suivant :

GLADIR.COM !
GLADIR.COM !
GLADIR.COM !
GLADIR.COM !

Maintenant que vous avez ajouté la boucle FOR/NEXT, vous n'avez pas à interrompre avec la touche STOP pour arrêter l'exécution du programme. Cette boucle FOR/NEXT fonctionne comme ceci :

Pour vous assurer que vous comprenez le fonctionnement de la boucle FOR/NEXT, nous ajouterons plus d'instructions PRINT à la ligne 20 vous permettant de suivre la valeur de I.

  1. 20 PRINT"GLADIR.COM !";"COMPTEUR =";I
  2. RUN     

On obtiendra le résultat suivant :

GLADIR.COM ! COMPTEUR = 1
GLADIR.COM ! COMPTEUR = 2
GLADIR.COM ! COMPTEUR = 3
GLADIR.COM ! COMPTEUR = 4


PARTAGER CETTE PAGE SUR
Dernière mise à jour : Lundi, le 12 décembre 2016