N'abend
ich weiß en detail nicht, wie sich regexes in Access verhalten, aber ich
glaube, ziemlich ähnlich zu denen in javascript.
D.h., es gibt dann doch einige Dinge, die zwar in perl, oder auch zB. python
relativ locker gehn, aber hier nicht.
So ist zB. das "sone Sache" mit der Formulierung beliebiger Ober - bzw. Untergrenzen
im pattern selbst, oder auch dem Aufspüren von Verdopplungen.
Ein grober Versuch einer Erklärung (genauer geht's momentan nicht, alldieweil
Ferien sind und das Haus voller Kinder):
<html>
<head>
<title>regex</title>
<script>
var og = '11',
ug = '-25',
test = [" 10 + +9 + 11 + -9 + -8 ",
" 10 + +9 + 11 + 9 + -8 ",
" 10 + + 9 + 11 + 9 + -8 ",
" 10 + +9 + 11 + 19 + -8 ",
" 10 + +9 + 11 + -77 + -8 ",
" -7 + -17",
" -7 + - 17",
" rumumbel ",
" 00 "
],
rg = /^\s*[-+]?\d\d*\s*(\+\s*[-+]?\d\d*\s*)*$/,
rz = /[-+]?\d\d*/g,
// es folgt das gleiche in grün, nochmal ausführlicher und diesmal unter
// Verwendung des Konstruktors => new RegExp( pattern [, option[s]] )
rg = new RegExp( '^\\s*[-+]?\\d\\d*\\s*(\\+\\s*[-+]?\\d\\d*\\s*)*$' ),
// das sieht ziemlich blöde aus, also nochmal in übersichtlich, aufgeteilt
// in kleine appetitliche häppchen, die dann zusammenfügt werden:
v = '[-+]?' , // vorzeichen ( entweder + oder minus ), mit dem
// ?-quantifier, also: ein- oder keinmal
d = '\\d' , // ziffer, digit, von 0 bis neun, kann auch
// als zeichenklasse geschrieben werden: [0-9],
// oder auch [0123456789]
// eigentlich: \d, aber weil in string: \\d
db = '\\d*' , // dasselbe mit *-quantifier, also: beliebig oft ( 0, 1, oder mehr)
w = '\\s*' , // beliebig viel whitespace
tr = '\\+' , // beliebiges trennzeichen, hier ein literales +
// ein escape wg. sonderzeichen und
// ein escape wg. escape des escapes in string
// das + ist ein regex sonderzeichen:
// der +-quantifier ( mindestens einmal, oder beliebig oft )
z = v + d + db, // beliebige zahl
zw = w + z + w, // dito, mit umgebenden beliebigem whitespace
rg = new RegExp( '^' + // anker: zeilenanfang, hier stringanfang
zw +
'(' + // einfangende und gruppierende klammer öffnend
tr +
zw +
')*' + // einfangende und gruppierende klammer schließend
// mit *-quantifier: beliebig oft
'$' // anker: zeilenende, hier stringende
),
rz = new RegExp( z, 'g' ) // g ist die option für's globale matching
// d.h.: finde jedes vorkommen diese patterns im
// gegebenen string
alert( rg + '\n\n' + rz ) // nur mal zum guggen, ob die konstruierten
// regexes auch hinhaun
if ( !isNaN( og*1 ) && !isNaN( ug*1 ) ) // sind og und ug tatsächlich brauchbare zahlen
if ( og*1 >= ug*1 ) // und ist og wirklich mindestens so groß wie ug
for( var i in test )
{ var x, y,
a = [],
s = 0,
f = 0
if( x = rg.exec( test[i] ) ) // stimmt die struktur insgesamt?
{
if( x[1] ) // das ist der sinn der einfangenden klammer:
// wenn sich nach der ersten zahl mindestens ein
// vorkommen des musters \+\s*[-+]?\d\d*\s* findet
{
while( y = rz.exec( test[i] ) ) a.push( y*1 ) // schaufle alle [-+]?\d\d* als
// numerische werte ins array a
for ( var j = 0; j < a.sort().length; j++ ) // array a wird aufsteigend
// sortiert und auf doppelte
// nachbarn abgeklopft bzw. og und ug
if( a[j] == a[j+1] )
{ alert('test[' + i + '] ' + a[j] + ' ist doppelt\n\n:' + test[i]);
s = 0;
f = 1;
break;
}
else if( a[j] > og*1 )
{ alert('test[' + i + '] ' + a[j] + ' ist zu groß\n\n:' + test[i]);
s = 0;
f = 1;
break;
}
else if( a[j] < ug*1 )
{ alert('test[' + i + '] ' + a[j] + ' ist zu klein\n\n:' + test[i]);
s = 0;
f = 1;
break;
}
else s += a[j]
}
else s = x[0]*1
if( !f ) alert( 'test[' + i + '] ' + ' summe => ' + s)
}
else alert( 'test[' + i + "] nüscht wg:\n\n" + test[i] )
}
else alert( og + ' kleiner ' + ug)
else alert( ' tja, zahlen sind halt ein eher abstraktes konzept ')
</script>
</head>
<body>
</body>
</html>
gruß
matho
