Mes petites idées

Bonjour,
et merci pour ce langage sublime mis sur pied ! C'est un boulot énorme que de créer un langage de programmation !
Il commence à être assez complet malgré sont jeune age Smile

C'est donc pour cela que j'ai quelques idées qui me sont venues, des idées piquées à d'autres langages principalement au PHP qui est un langage très souple et puissant Smile

j'en suis fan !

Donc mes idée :

1* Pouvoir avoir la main sur la gestion des erreurs (cgoisir les types a afficher, tous, aucun, seulement lui etcc)
2*avoir une fonction explode genre:
EXPLODE(D,S) >> D= DATA , S= SÉPARATEUR
Bien sur il faut gérer la création du tableau en auto. (en php c'est auto en tout cas)

Code:: <?php
$chaine = '1,2,3,4,5,6';
$array_chaine = explode(',',$chaine);
//Ensuite on traitent comme on veux.
//Ou un foreach ou alors directement sue le tab.

foreach($array_chaine as $r)
{
echo'le chiffre présent est'.$r;
}

echo $array_chaine[0]; //Affiche 1
?>

3*LES REGEX !!!!!
Pour faire un exemple des plus basique !
On va dire que j'ai une varialbe genre:

Code:: dim Ma_chaine$
Ma_Chaine$ = "J'ai un bel ordinatateur et je code en panoramic "
//On veux charger le mot ordinateur, puis après ordinateur ET paniramic.

if (REGEX(#ordinateur#,Ma_Chaine$) =1
print "La chaine contient bien ordinataeur !"
else
print "Ce mot n'est pas présent"
end_if

rem On passe à la suite:
if(REGEX(#ordinateur|panoramic,Ma_Chaine$) =1
print "La chaine contient bien un des deux mot ou les deux faire la première soluce pour mieux ciblé"
else
print "Non aucune des mot n'est ici !"
end_if

Puis on pourrait avoir donc les option universelle :
[0-9][a-z] [A-Z][A-0-9-Z] //Je vous laisse comprendre cette ligne

et utiliser donc des caractères pour différentes actions Smile

chercher, remplacer, compter etc...

Voilà merci Smile

Qu'en pensez vous ?

Les "regular expression" permettent de faire de choses fantastiques...
C'est un outil très puissant et très utile en Php ou C mais peut être un peu trop complexe pour un langage comme le BASIC...
Jack (corrige moi si je me trompe), a créé ce langage pour des programmeurs du dimanche (Attention, ce n'est pas dans le sens péjoratif ce que je dis ! )
et je pense, qu'il souhaite maintenir son accessibilité à une grande majorité de personnes...

La compréhension d'un tel outil n'est pas chose aisé, il n'y a qu'a voir les demandes d'aide auprès de Chinoisfurax et autres personnes sur un site que je ne nommerai pas par ne pas froisser la susceptibilité de certaines personnes... Wink

Si les expressions regulières étaient mise en place sous Panoramic, le forum se remplirai très rapidement de demande d'aide...

Qui peut comprendre un truc comme ça :
'#((?(?!//)(?:[^\'"])|(?m://.*$)?)*)((?sU:([\'"]).*(?<!\\\)\3))((?sU:(?(?!(?3)).$)*))#' ??

Pour la petit histoire, je me suis déjà bien cassé les dents en PHP avec les regex : voir ici
Wink

Bah sa va après ce n'est pas non plus la fin du monde à comprendre une regex Smile

suffit d'avoir de la mémoire ^^.

Au pire on peut alors user des mot clé ??
ou créer un système symple de regex alors ??
J'aime trop pour m'en passer : p

Ce que je propose sinon bah les regex de base comme la recherche d'un mot et expression avec #(*)# et les opé loquique de base alors

if(![regex] avec le ! avant => si == false alors
le fameux || pour signiter Ou
l'incontournable && pour dire ET (de manière obligatoire)
et après au moins un minimum en fait je pense
En programmation c'est vraiment indispensable même pour un langage qui veut être simple.
Ou avoir un substitue..

Je pense que l'idée est valable mais je ne pense pas que la forme corresponde à ce que Jack veut mettre en place, (mais bon, il répondra lui même la dessus, ce n'est que mon interprétation).
Le ! devant ou le || corresponde au PhP, au C, etc, mais pas à Panoramic.
Les substitus * ou ? pourraient être incorporé mais en Panoramic, à Priori, Jack mettrait plutôt une fonction du type ESTFAUX par exemple (je mets le nom comme ça, mais c'est surtout l'esprit, je pense) et à la place de ||, il met OU et pour &&, il utilsera plutôt directement ET pour que cela soit plus directement lisible par un néophyte, même si les programmeurs confirmés sont ou peuvent être un peu déroutés.
De toute façon ces programmeurs pour la plus part utilise déjà PHP ou Visual C, C++ ou autre langage de programmation.
Voilà, je t'ais donné mon avis en attendant la réponse de Jack.
Perso, j'aimerais bien aussi que l'on puisse directement donner le format autorisé d'une saisi (nombre de caractères, caractères autorisés par exemple) mais ça c'est une autre histoire même si la syntaxe pourrait ressembler

Oui peut etre peut-on alors simplifer la chose (niveau dela syntaxe) tout en gardant la puissance de l'outils ?

Comme j'aimerai que ce soit possible ! cheers

Et pour l'explode ?
Aucun comment >>?

Si si, pour l'explode on est tellement d'accord que cosmos en a programmé un dans son outil. Après, le nom de la fonction sera sans doute différent pour correspondre aux autres syntaxes, mais bien évidemment, c'est une fonction très utile

Alors sa va ! Smile

Plus qu'a attendre JACk pour avoir l'avis de dieu :p

Pour la recherche d'un mot dans une chaine tu as déja la fonction instr(s1$,s2$) si je ne m'abuse ....

Code:: dim s1$,s2$,s3%

s1$="La maison est verte"
s2$="est"

s3%=instr(s1$,s2$)

if s3%>0 then message "Ok !"

Oui mais j'ai pris l'exemple de la recherche avec la regex #$str# car c'est la base de regex.

Mais à la base, enfin peut s'en servir pour faire une recherche mais les regex c'est un outils très puissant, et on peut vraiment aller très loin dans l'analyse d'une chaîne de caractère et faire TOUS type de vérifiction et de test dessus.

Après il faut pas non aller trop dans le compliqué quoi...
genre :
Un VRAI expression pour vérifier TOUS les types D'emails !

Code:: (?:(?:rn)?[ t])*(?:(?:(?:[^()<>@,;:".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t]
)+|\Z|(?=[\["()<>@,;:".\[\]]))|"(?:[^"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:
rn)?[ t])*)(?:.(?:(?:rn)?[ t])*(?:[^()<>@,;:".\[\] \000-\031]+(?:(?:(
?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:".\[\]]))|"(?:[^"\r\\]|\\.|(?:(?:\r\n)?[
\t]))*"(?:(?:rn)?[ t])*))*@(?:(?:rn)?[ t])*(?:[^()<>@,;:".\[\] \000-\0
31]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:".\[\]]))|\[([^\[\]\r\\]|\\.)*\
](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".[] 000-031]+
(?:(?:(?:rn)?[ t])+|Z|(?=[["()<>@,;:\\".[]]))|[([^[]r]|.)*](?:
(?:rn)?[ t])*))*|(?:[^()<>@,;:".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z
|(?=[\["()<>@,;:".\[\]]))|"(?:[^"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:rn)
?[ t])*)*<(?:(?:rn)?[ t])*(?:@(?:[^()<>@,;:".\[\] \000-\031]+(?:(?:(?:\
r\n)?[ \t])+|\Z|(?=[\["()<>@,;:".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[
\t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".[] 000-031]+(?:(?:(?:rn)
?[ t])+|Z|(?=[["()<>@,;:\\".[]]))|[([^[]r]|.)*](?:(?:rn)?[ t]
)*))*(?:,@(?:(?:rn)?[ t])*(?:[^()<>@,;:".\[\] \000-\031]+(?:(?:(?:\r\n)?[
\t])+|\Z|(?=[\["()<>@,;:".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*
)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".[] 000-031]+(?:(?:(?:rn)?[ t]
)+|Z|(?=[["()<>@,;:\\".[]]))|[([^[]r]|.)*](?:(?:rn)?[ t])*))*)
*:(?:(?:rn)?[ t])*)?(?:[^()<>@,;:".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+
|\Z|(?=[\["()<>@,;:".\[\]]))|"(?:[^"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:r
n)?[ t])*)(?:.(?:(?:rn)?[ t])*(?:[^()<>@,;:".\[\] \000-\031]+(?:(?:(?:
\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:".\[\]]))|"(?:[^"\r\\]|\\.|(?:(?:\r\n)?[ \t
]))*"(?:(?:rn)?[ t])*))*@(?:(?:rn)?[ t])*(?:[^()<>@,;:".\[\] \000-\031
]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:".\[\]]))|\[([^\[\]\r\\]|\\.)*\](
?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".[] 000-031]+(?
:(?:(?:rn)?[ t])+|Z|(?=[["()<>@,;:\\".[]]))|[([^[]r]|.)*](?:(?
:rn)?[ t])*))*>(?:(?:rn)?[ t])*)|(?:[^()<>@,;:".\[\] \000-\031]+(?:(?
:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:".\[\]]))|"(?:[^"\r\\]|\\.|(?:(?:\r\n)?
[ \t]))*"(?:(?:rn)?[ t])*)*:(?:(?:rn)?[ t])*(?:(?:(?:[^()<>@,;:".\[\]
\000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:".\[\]]))|"(?:[^"\r\\]|
\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:rn)?[ t])*)(?:.(?:(?:rn)?[ t])*(?:[^()<>
@,;:".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:".\[\]]))|"
(?:[^"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:rn)?[ t])*))*@(?:(?:rn)?[ t]
)*(?:[^()<>@,;:".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:
".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?
:[^()<>@,;:\\".[] 000-031]+(?:(?:(?:rn)?[ t])+|Z|(?=[["()<>@,;:\\".[
]]))|[([^[]r]|.)*](?:(?:rn)?[ t])*))*|(?:[^()<>@,;:".\[\] \000-
\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:".\[\]]))|"(?:[^"\r\\]|\\.|(
?:(?:\r\n)?[ \t]))*"(?:(?:rn)?[ t])*)*<(?:(?:rn)?[ t])*(?:@(?:[^()<>@,;
:".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:".\[\]]))|\[([
^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\"
.[] 000-031]+(?:(?:(?:rn)?[ t])+|Z|(?=[["()<>@,;:\\".[]]))|[([^[
]r]|.)*](?:(?:rn)?[ t])*))*(?:,@(?:(?:rn)?[ t])*(?:[^()<>@,;:".\
[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:".\[\]]))|\[([^\[\]\
r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".[]
000-031]+(?:(?:(?:rn)?[ t])+|Z|(?=[["()<>@,;:\\".[]]))|[([^[]r]
|.)*](?:(?:rn)?[ t])*))*)*:(?:(?:rn)?[ t])*)?(?:[^()<>@,;:".\[\] \0
00-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:".\[\]]))|"(?:[^"\r\\]|\\
.|(?:(?:\r\n)?[ \t]))*"(?:(?:rn)?[ t])*)(?:.(?:(?:rn)?[ t])*(?:[^()<>@,
;:".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:".\[\]]))|"(?
:[^"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:rn)?[ t])*))*@(?:(?:rn)?[ t])*
(?:[^()<>@,;:".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:".
\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[
^()<>@,;:\\".[] 000-031]+(?:(?:(?:rn)?[ t])+|Z|(?=[["()<>@,;:\\".[]
]))|[([^[]r]|.)*](?:(?:rn)?[ t])*))*>(?:(?:rn)?[ t])*)(?:,s*(
?:(?:[^()<>@,;:".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:
".\[\]]))|"(?:[^"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:rn)?[ t])*)(?:.(?:(
?:rn)?[ t])*(?:[^()<>@,;:".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[
\["()<>@,;:".\[\]]))|"(?:[^"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:rn)?[ t
])*))*@(?:(?:rn)?[ t])*(?:[^()<>@,;:".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t
])+|\Z|(?=[\["()<>@,;:".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?
:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".[] 000-031]+(?:(?:(?:rn)?[ t])+|
Z|(?=[["()<>@,;:\\".[]]))|[([^[]r]|.)*](?:(?:rn)?[ t])*))*|(?:
[^()<>@,;:".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:".\[\
]]))|"(?:[^"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:rn)?[ t])*)*<(?:(?:rn)
?[ t])*(?:@(?:[^()<>@,;:".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["
()<>@,;:".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)
?[ \t])*(?:[^()<>@,;:\\".[] 000-031]+(?:(?:(?:rn)?[ t])+|Z|(?=[["()<>
@,;:\\".[]]))|[([^[]r]|.)*](?:(?:rn)?[ t])*))*(?:,@(?:(?:rn)?[
t])*(?:[^()<>@,;:".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,
;:".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t]
)*(?:[^()<>@,;:\\".[] 000-031]+(?:(?:(?:rn)?[ t])+|Z|(?=[["()<>@,;:\\
".[]]))|[([^[]r]|.)*](?:(?:rn)?[ t])*))*)*:(?:(?:rn)?[ t])*)?
(?:[^()<>@,;:".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:".
\[\]]))|"(?:[^"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:rn)?[ t])*)(?:.(?:(?:
rn)?[ t])*(?:[^()<>@,;:".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\[
"()<>@,;:".\[\]]))|"(?:[^"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:rn)?[ t])
*))*@(?:(?:rn)?[ t])*(?:[^()<>@,;:".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])
+|\Z|(?=[\["()<>@,;:".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\
.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".[] 000-031]+(?:(?:(?:rn)?[ t])+|Z
|(?=[["()<>@,;:\\".[]]))|[([^[]r]|.)*](?:(?:rn)?[ t])*))*>(?:(
?:rn)?[ t])*))*)?;s*)

Voila après c'est de l'extrem.
Mais on peut faire simple avec des mot clé en fait je pense. Et du coup aller aussi lion.

=> Mots clés + opé logique Smile

Tu vois ton exemple....

Là est la différence entre un pro de la prog et un amateur comme la plupart d'entre nous,
ce qui fait que l'on est là et pas chez php , Vb ou C++ voir d'autres.

pour les "comme moi" ton exemple est un tableau de hiéroglyphes farao

venus d'une galaxie alien

,
vu que l'on est déjà tous sur une autre planète alien

Justement je pense que avec des mot clé simple et des action prédéfini et un peu de logique on peut faire une syxtaxe ultra simplifer.

REGEX_CHIFFRE(0,9,CHAINE_A_ANALYSER) => On regarde si la chaine ne combien QUE des chiffres de 0 à 9 !
REGEX_LETTRE_MIN(CHAINE_A_ANALYSER) => On regarde que la chaine n'ai que des lettre minuscule

Enfin ya moyen de mettre en place une trantaire de mot clé facile pour gerer dyfférent type de cas.

Une utilisation comme celle ci reste vraiment très simple et ma fois reste quand même ultra compréhensible !

Ce qui permet dérrière de faire du traitement un peu plus poussé.
Moi j'en ai besoin pour certaine chose et je suis un peu coincé là donc je fait des feinte ^^, et je ne pense pas être le seul ??
albino

Là tu commences à parler en PANORAMICIEN cheers

Tu vois que ca vient lol!

( heuuu....pour les minuscules ...je crois qu'il y a déjà quelque chose
mais ma pose de qqs jours a fait des trous ds ma mémoire de poisson rouge Laughing

)

Bah je suis d'accord que le fait que si il y a une majorité d'amateur qui ne connaisse que le panoramic, les regex c'est dur à avaler.

Mais pour la suite si on peut faire un système simple c'est le top !

lol!

Oui c'est rentré ^^

Des fonctions comme celles que tu évoques (REGEX_CHIFFRE et REGEX_LETTRE_MIN), je peux les réaliser dans une DLL. Si cela t'intéresse...

Bah oui carrément !
À ce propros Smile

Tu as un MP de moi sur le forum Smile

Je crois que Klaus a raison : pour des besoins spécifiques il est plus sage de passer par une DLL... Wink

Reste à savoir, sous qu'elle forme/moyen tu veux récupérer le résultat de ta regex...

PS: il ne faut pas oublier la signification de la 1ere lettre du mot 'BASIC'... Wink

Le truc c'est que je n'ai jamais bosser sous window ^^ c'est tout nouveau pour moi.
Et je ne sais pas comment on créer une DLL !si vous avez des liens pour apprendre ?
Je vais vous en pondre un gros tas :p De tout ce que j'ai besoins ^^

J'aime pas être limité Twisted Evil

Tu trouveras des sources sur mon site et Klaus se fera certainement un plaisir de t'expliquer tout ça... Wink

Mais peut être que tu devrais commencer par te familiariser avec Panoramic avant de chercher à rajouter des fonctionnalités...
C'est un bon exercice de chercher à "contourner" un problème... Very Happy

Ah oui pas mal de chose sur ton site Smile

J'aime bien Smile

J'attend de Klaus revienne pour papoter avec lui.

Il faudrait également un chat ici Smile

sa serait pratique !

Pour le chat, je pense que cela ne serait pas trop compliqué de mettre en place ceci Wink

Pourrait on reprendre les discussions pendant notre absence sur un sujet Question

» Petites Questions ....
» Les petites licornes
» Petites améliorations vraiment sympa et pros
» deux petites subs
» Petites icônes dans les sub_menu