JavaScript REGEXP - Három [A-Z] és két [0-9] bármilyen kombinációban

Programozás - kezdő

Üdvözletem!

A következőben szeretném a segítségeteket kérni:

Szükségem van egy olyan JavaScript REGEXP kifejezésre, ami például a következő stringeket engedi:

ABC12
D8Z9T
GL65N

azoban a következő típusokat tiltja:

1ABA2 - ismétlődő betűk
1AB1C - ismétlődő számok
12345 - 2-nél több szám
ABCDE - 3-nál több betű
AB12 - 5-nél kevesebb karakter
ABC123 - 5-nél több karakter

Csak a nagybetűk engedélyezettek!

Azt tudom, hogy a karaktereket így korlátozom, de ez ugyebár nem szűri ki például a duplázódásokat:

^[A-Z0-9]{5}$

Segítségeteket előre is köszönöm!

Üdv: t!

( mauzi v | 2013. 09. 23., h – 20:48 )

Regexpben ilyen állat márpedig nincsen...

Tényleg nem sok:
-ha nem pontosan öt darab nagybetű-szám karakterből áll, akkor visszadobja, hogy hibás - egy regexp.
Ha pontosan öt hosszú, és csak nagybetűt-számot tartalmaz, akkor szétszeded karakterenként egy tömbbe, a tömböt rendezed: 


var s="3ZX2A";
var t=[];
for(i=0; i<=4; i++) { t[i]=s.substr(i,1) }
t=t.sort();

Ha a tömb 2. eleme betű, vagy a 3. eleme szám, akkor hibás a kapott string, továbbá ha végigmész a tömbön, és van benne két azonos érték, akkor is. Ezt már meghagyom a kérdezőnek :-P
Persze a rendezett tömbből lehet stringet csinálni, amire egy jól irányzott regexp is elég :)

Vagy egy másik ötlet, két ciklussal: a külsőben i-vel végigmész 0-től 3-ig, a belsőben meg j-vel i+1-től 4-ig. A belső ciklusban a string i-edik és j-edik karakterét összehasonlítod - ha azonosak, a validáló függvényed hibával visszatér.
A külső ciklusban még megnézed, hogy az i-edik karakter szám-e, ha igen, akkor egy n változó értékét növeled. Ha n értéke nagyobb lesz, mint kettő, szintén visszatérhetsz hibával.
A külső ciklus után még megnézed a string i+1. (utolsó) karakterét, hogy szám-e, ha igen, növelsz egyet az n-en. Ha n értéke nem egyenlő 2-vel, akkor hibával, egyébként meg "rendben"-nel térhet vissza a validáló függvényed.

Nem tudom, erre az udvarias stilusra hozhatnal valami ertelmes referenciat. Meg nem lattam, hogy ennek lett volna barmi ertelme - a magyarban maga a magazodo stilus az udvariaskodas. Angoloknal tudom ezt elkepzelni, mert ott nincs kifejezett magazodas, hanem a szovalasztassal es a roviditesek elhagyasaval fejezik ki a formal kommunikaciot.

Arrol nem beszelve, hogy jelen esetben meg csak a gyanu sem all fenn.
-- 

Ki oda vagyik, hol szall a galamb, elszalasztja a kincset itt alant.

> Nem tudom, erre az udvarias stilusra hozhatnal valami ertelmes referenciat.
http://mek.oszk.hu/01500/01547/01547.pdf, 149. pont:

Fokozott tisztelet kifejezésére azonban az ilyen esetekben nagybetű is alkalmazható: Szeretném, Apám, ha nem értene félre. A legfőbb érdem az Önöké.

Ez levelekben, hivatalos iratokban alkalmazható. 1985-ben (a tizenegyedik kiadás létrejöttekor) még ritka volt a fórumposzt, viszont elég közel áll hozzá. Én nem értek egyet a használatával, esetleg hivatalos levélben én is leírnám.

hrgy84 te meg mindenkibe belekötsz helyesírás-ügyileg, és többedszerre derül ki, hogy talán mégsem neked van igazad.

Kösz, én meg nem találtam volna...
Anno, amikor megboldogult magyar tanárom a hivatalos levelet tanította, említette. Sokat leveleztem ügyfelekkel, és hozzászoktam - gyakorlatilag mindenhol (még családon belül is így) használom, mert berögzült.
Sőt, a Veled, Neked, Benned, Hozzád, stb. is így jön - néha sajnos, de ez van - automatikusan.
--
PtY - www.onlinedemo.hu

El tudom kepzelni, hogy nekem ujabb helyesirasi szabalyzatot tanitottak, vagy pedig hianyos volt a magyartanarom ilyen iranyu magyarazata, mert en egyaltalan nem tudtam arrol, hogy ilyen szabaly letezik, sot egyszer veletlenul igy irtam valamit, akkor pirossal ala is huzta. Mentsegemre szolt, hogy fogalmazas volt, es eleve a regies stilust tuztem ki celul, igy a vegen nem jart erte pontlevonas.

"mindenkibe belekötsz helyesírás-ügyileg, és többedszerre derül ki, hogy talán mégsem neked van igazad."

Csak az nem hibazik, aki nem dolgozik. En ezt nem elem meg akkora tragediakent, rengeteget lehet ilyenekbol is tanulni.
-- 

Ki oda vagyik, hol szall a galamb, elszalasztja a kincset itt alant.

> El tudom kepzelni, hogy nekem ujabb helyesirasi szabalyzatot tanitottak
FYI, az 1985-ös, tizenegyedik kiadás volt érvényben 2011-ig biztosan, de talán még ma is. Szóval nem lehet elképzelni, hogy ennél újabbat tanítottak neked. Két lehetőséget látsz: vagy a magyartanárod volt hülye, vagy mást tanított, de az fel nem merülne benned, hogy egyszerűen: rosszul tudtad.

Az igazság kedvéért tegyük hozzá, hogy az akkori tankönyvekben a levélírás és annak szabályai a futottak még kategóriában voltak (de szerepeltek): gondoljunk csak bele, hány fogalmazást kellett írni nyári/téli élményekről, ill. olvasmányokról és hányszor kellett levelet írni ilyen céllal, és ebből hányszor nem családtagnak!

( joco01 v | 2013. 09. 23., h – 21:45 )

Szerintem egy rakat zero-width assertion kellhet ide, de rohadt undorító lesz, ezt amúgy tényleg nem regexppel kellene...

--

( zamboriz v | 2013. 09. 23., h – 22:18 )

perl-ben valami ilyesmi: 



@test = (
  'ABC12',
  'D8Z9T',
  'GL65N',

  '1ABA2',
  '1AB1C',
  '12345',
  'ABCDE',
  'AB12',
  'ABC123',
);

$regexp = '^((([A-Z])(?!.*\g{-1})([A-Z])(?!.*\g{-1})([A-Z])(?!.*\g{-1})([0-9])(?!.*\g{-1})([0-9])(?!.*\g{-1}))|(([A-Z])(?!.*\g{-1})([A-Z])(?!.*\g{-1})([0-9])(?!.*\g{-1})([A-Z])(?!.*\g{-1})([0-9])(?!.*\g{-1}))|(([A-Z])(?!.*\g{-1})([A-Z])(?!.*\g{-1})([0-9])(?!.*\g{-1})([0-9])(?!.*\g{-1})([A-Z])(?!.*\g{-1}))|(([A-Z])(?!.*\g{-1})([0-9])(?!.*\g{-1})([A-Z])(?!.*\g{-1})([A-Z])(?!.*\g{-1})([0-9])(?!.*\g{-1}))|(([A-Z])(?!.*\g{-1})([0-9])(?!.*\g{-1})([A-Z])(?!.*\g{-1})([0-9])(?!.*\g{-1})([A-Z])(?!.*\g{-1}))|(([A-Z])(?!.*\g{-1})([0-9])(?!.*\g{-1})([0-9])(?!.*\g{-1})([A-Z])(?!.*\g{-1})([A-Z])(?!.*\g{-1}))|(([0-9])(?!.*\g{-1})([A-Z])(?!.*\g{-1})([A-Z])(?!.*\g{-1})([A-Z])(?!.*\g{-1})([0-9])(?!.*\g{-1}))|(([0-9])(?!.*\g{-1})([A-Z])(?!.*\g{-1})([A-Z])(?!.*\g{-1})([0-9])(?!.*\g{-1})([A-Z])(?!.*\g{-1}))|(([0-9])(?!.*\g{-1})([A-Z])(?!.*\g{-1})([0-9])(?!.*\g{-1})([A-Z])(?!.*\g{-1})([A-Z])(?!.*\g{-1}))|(([0-9])(?!.*\g{-1})([0-9])(?!.*\g{-1})([A-Z])(?!.*\g{-1})([A-Z])(?!.*\g{-1})([A-Z])(?!.*\g{-1})))$';

foreach $t (@test){
  print $t," ",(($t=~m/$regexp/)?'match':'no-match'),"\n";
}

eredmény: 


ABC12 match
D8Z9T match
GL65N match
1ABA2 no-match
1AB1C no-match
12345 no-match
ABCDE no-match
AB12 no-match
ABC123 no-match

> ezt a regexpet könnyebb lehetett megírni, mint megérteni

Így készült, ebből jobban látszik a szerkezete: 


@t=(
  'aaa99',
  'aa9a9',
  'aa99a',
  'a9aa9',
  'a9a9a',
  'a99aa',
  '9aaa9',
  '9aa9a',
  '9a9aa',
  '99aaa'
);

foreach $t (@t){
  $t =~ s/a/([A-Z])(?!.*\\g{-1})/g;
  $t =~ s/9/([0-9])(?!.*\\g{-1})/g;
}

print join(')|(',@t), "\n";

Plusz pár karakter kézzel.

Én se értem, mi értelme van a Perl-nek, amikor ott a jó öreg C...

Néhány hete vagy talán hónapja rábukkantam a "vidir" nevű programra. Nagyon megörültem neki. Nézegetem, hű, ez tök rövid, oké, csekkoljuk csak meg a forrást hogyan csinálja a fejlesztője, hátha tanulok belőle valamit... Erre nagy döbb és zizz: Pffffff... Ez biza nem C-ben van, nem is C++-ban hanem PERL-ben! Pedig én hogy úgy mondjam "el akartam lopni", beépíteni az egészet egy készülő programomba...

Link

Nekem nincs ilyen fetisem, hogy valami csak x nyelvben lehet, a legtobb elterjedt nyelv tavolrol elegge ugyanolyan. C/C++, Java, C#, PHP, Bash, akarmi. De amikor ranezek a Perl kodra, elfog a hanyinger. A my, a {}{}{}{}{}, a regex, komolyan, REGEX?! Nem sok olyan (szamomra) undorito dolog van a programozasban, mint a regexek, erre a Perl tele van vele. Aki irta, az mondjuk erti legalabb 2 napig, utana meg egy szenvedes kibogoznia. Barki masnak meg agyhalal. Oke, hogy nagyon hatekonyan lehet kifejezni dolgokat, de olvashatosag, debugolas, karbantarthatosag, ujrafelhasznalhatosag szempontjabol a zerohoz konvergal. Nekem kb. olyan, mintha brainfuck kodot olvasnek. Innentol eselytelen, hogy en es a Perl valaha baratok legyunk.

Link

De legalább reménykedjünk abban, hogy szebbek, mint amilyen okosak...

--
PtY - www.onlinedemo.hu

Azért egy tömör perl program inkább emlékeztet valami... minek is hívják? Obfuszkált? :D Szóval amolyan jól megkavart forráskódra, mint tisztességes programra.
Jól olvashatónak meg általában nem nevezhető.
Persze ez inkább user error, nem a nyelv hibája.

Aki tudja, csinálja, aki nem tudja, tanítja... Hm... igazgatónak talán még jó lennék. :)

Pontosan.
Verhás Péter ezt szépen összefoglalta:

"Ha eddig azt gondoltad, hogy a PASCAL a szépen és dokumentáltan programozható nyelv, és C-ben kegyetlenül olvashatatlan programokat lehet írni, akkor most értékeld át a dolgot: PASCAL-ban szépen formátumozott programokat lehet írni, C-ben olvashatatlan és Perl-ben kegyetlenül olvashatatlan programokat. Lehet. De nem kell."

- o -

Akinek pedig a programozás azt jelenti, hogy más forrásrészleteit nyúlja le, az vagy értse meg, amit ellop (és akkor akár át is hangszerelheti), vagy ha erre nem képes - a legnagyobb tisztelettel az író irányába - fogja be.
(Poli, ha esetleg magadra ismersz: direkt van.)

Miért?
Tényleg undorítóak, ha mélyebben belemászol.
Most ne a [0-9a-z]+^$ típusúra gondolj, hanem pl. tagadásra és egyéb kedvességekre! ;) (nem jut eszembe, szerintem Zahy-t szórakoztattuk egy tanfolyamon valami lehetetlen regexp kifejezés létrehozásával, amiben az egyik lényeges feltétel volt, hogy bizonyos dolgokat nem volt szabad tartalmaznia a kiválasztott sornak)

Aki tudja, csinálja, aki nem tudja, tanítja... Hm... igazgatónak talán még jó lennék. :)

man perlre
/Look-Around Assertions

"(?=pattern)"
A zero-width positive look-ahead assertion. For example,
"/\w+(?=\t)/" matches a word followed by a tab, without
including the tab in $&.

"(?!pattern)"
A zero-width negative look-ahead assertion. For example
"/foo(?!bar)/" matches any occurrence of "foo" that isn't
followed by "bar". Note however that look-ahead and
look-behind are NOT the same thing. You cannot use this
for look-behind.

(A ?! az első RE-s megoldásban szerepel.)

Nincs sok ertelme a ket vegletet (teljes ellenorzes egyetlen nagy regexp vs egylaltalan nem hasznalunk regexpet) osszehasonlitani szvsz. Nem-e lenne atlathatobb ha mindegyik kriteriumnak lenne kulon egy-egy fuggveny, pl. hasRepeatingLetters()?

----------------------
"ONE OF THESE DAYS I'M GOING TO CUT YOU INTO LITTLE PIECES!!!$E$%#$#%^*^"
--> YouTube csatornám

Nezd, ha valaki utalja a halat, mondhatsz neki barmit, meg azt is, hogy ma mar letezik teljesen halszagtalan/haliztelen hal is, akkor sem fog egy darabot sem megkostolni belole. Ezt tapasztalatbol mondom.

Ugyanez all a regexre is.
-- 

Ki oda vagyik, hol szall a galamb, elszalasztja a kincset itt alant.

Pont most akartam szólni a topiknyitónak hogy ezt nem lehet megoldani lineáris időben és ne akarjon már egy n=5-ös sortot megspórolni ilyen áron, de ezekszerint csak a második tagmondatban volt igazam. Szerintem a sort majd rövid regex elhanyagolhatóval rosszabb csak futásidőben, és megéri az olvashatóságot.

( littlet v | 2013. 09. 27., p – 21:28 )

(H)UP!

"Megmondtam, az Én scriptem hülyebiztos! Hülye biztos nem futtathatja!"

( Ajnasz v | 2013. 09. 29., v – 16:04 )

Ilyen csunyat irtam most: 

function isOk(str) {
    var alpha = 0,
        num = 0;

    /^[A-Z0-9]{5}$/.test(str) && str.replace(/[A-Z0-9]/g, function (a) {
        (/[A-Z]/.test(a))? ++alpha : ++num;
    });

    return alpha === 3 && num === 2;
}

--
HUP Firefox extension

( pityulaman1983 v | 2013. 09. 30., h – 16:25 )

"Három [A-Z] és két [0-9] bármilyen kombinációban"

Tehát neked 5 db alfanumerikus karaktered van? :)

\w{5}

-----------
"640GB sokmindenre elég"

Ha munkát keresel, akkor kezdd az elején: írj CV-t.