Solicitar uma string com: Upper, Lower, Numero e Especiais

[mauricioportela]

Exemplo que solicita ao usuario que digite uma sequencia de caracteres, respeitando o seguinte criterio:

Ter no minimo:
1 caractere Maiusculo;
1 caractere Minusculo;
1 Digito (Numero)
1 caractere Especial (@#_-+=/*)

Compilar: hbmk2 teste.prg

Código: Selecionar todos

#include "inkey.ch"

FUNCTION Main()
    LOCAL cNome
    cls
    @ 02, 02 SAY "Exemplo de Vericacao de Criterio para o Texto com Cifragem"
    @ 03, 02 SAY "(ESC = Sair)"
    @ 04, 02 SAY "Digite um Nome com pelo menos:"
    @ 05, 02 SAY "* uma letra maiuscula;"
    @ 06, 02 SAY "* uma letra minuscula;"
    @ 07, 02 SAY "* um digito"
    @ 08, 02 SAY "* um caractere especial (@#_-+=/*)"
    
    WHILE .t.
        @ 09, 02, 23, 79 BOX SPACE(9)
        cNome := SPACE(15)
        @ 12, 10 say "Digite um Nome :" GET cNome
        READ
        IF LASTKEY() == K_ESC
            EXIT
        ENDIF
        if !VerificaCriterioTexto(cNome)
            // Se nao antender, sair ...
            ALERT("O nome informado nao preenche os requisitos!")
            @ 23, 00
            return -1
        endif
        cNome := CifraDados(cNome)
        @ 14, 10 SAY "Nome Cifrado   : " + cNome
        cNome := DecifraDados(cNome)
        @ 16, 10 SAY "Retorno do Nome: " + cNome
        @ 23, 02 SAY "Pressione algo ..."
        INKEY(0)
    ENDDO
    CLS
RETURN Nil

FUNCTION CifraDados(cTexto)
    LOCAL lFlag := .T., cResultado := "", cCifraLetra := ""
    FOR cLetra := 1 TO LEN(cTexto)
        cCifraLetra := CHR(ASC(SUBSTR(cTexto, cLetra, 1))+ IIF(lFlag, +31, -31))
        cResultado += cCifraLetra
        lFlag := !lFlag
    NEXT
RETURN cResultado

FUNCTION DecifraDados(cTexto)
    LOCAL lFlag := .T., cResultado := "", cLetraLimpa := ""
    FOR cLetra := 1 TO LEN(cTexto)
        cLetraLimpa := CHR(ASC(SUBSTR(cTexto, cLetra, 1))+ IIF(lFlag, -31, +31))
        cResultado += cLetraLimpa
        lFlag := !lFlag
    NEXT
RETURN cResultado

FUNCTION VerificaCriterioTexto(cTexto)
    LOCAL lUpper, lLower, lDigit, lEspecial, cGrpChr, aResultado, cMensagem
    lUpper := lLower := lDigit := lEspecial := .F.
    cGrpChr    := "@#_-+=/*"
    aResultado := {}
    FOR n := 1 TO LEN(cTexto)
        cSinal := SUBSTR(cTexto, n, 1)
        IF IsUpper(cSinal)
            lUpper := .T.
        ELSEIF IsLower(cSinal)
            lLower := .T.
        ELSEIF IsDigit(cSinal)
            lDigit := .T.
        ELSEIF (cSinal $ cGrpChr)
            lEspecial := .T.
        ENDIF
    NEXT
    cMensagem := "Essa string nao contem pelo menos um:;"
    IF !lUpper
        cMensagem += "- Maiusculo.;"
    ENDIF
    IF !lLower
        cMensagem += "- Minusculo.;"
    ENDIF
    IF !lDigit
        cMensagem += "- Digito.;"
    ENDIF
    IF !lEspecial
        cMensagem += "- Caractere Especial.;"
    ENDIF
    IF (!lUpper .or. !lLower .or. !lDigit .or. !lEspecial)
        alert("Aviso:;" + cMensagem)
        RETURN .F.
    ENDIF
RETURN .T.

Dá pra melhorar!

Att.
Mauricio Portela

[Itamar M. Lins Jr.]

Olá!
Usando REGEX isso tudo fica em 1 linha. ATENÇÃO EU NÃO SEI FAZER! Peguei na internet mas felizmente entendo que ficará mais ou menos assim no Harbour.
https://pt.stackoverflow.com/questions/ ... enha-forte

Código: Selecionar todos

/^(?=.*\d)(?=.*[a-z])(?=.*[A-Z])(?=.*[$*&@#])[0-9a-zA-Z$*&@#]{8,}$/

Código: Selecionar todos

FUNCTION ValidaFileName( cRuc, lShowError )
   LOCAL cRegEx := "^[a-zA-Z0-9](?:[a-zA-Z0-9 ._-]*[a-zA-Z0-9])?\.[a-zA-Z0-9_-]+$"
   LOCAL lIsValid := FALSE

   DEFAULT lShowError TO FALSE
#ifdef __XHARBOUR__
   IF ( AllTrim( cRuc ) LIKE cRegEx )
#else
   IF hb_RegexLike( cRegEx, AllTrim( cRuc ) )
#endif
      lIsValid := TRUE
   ENDIF

   IF lShowError .and. !lIsValid
      Alert( "File name not valid!" )
   ENDIF

RETURN lIsValid

https://groups.google.com/g/harbour-use ... Aae2UVBgAJ

Saudações,
Itamar M. Lins Jr.

[mauricioportela]

ola!

Legal o uso de regex. Mas, nesse caso, pula a identificação do critério que falta. Pois tá tudo na mesma expressão.

Quanto a regex, eu vi alguma coisa num livro do Aurelio Jargas. No site dele tem bastante material. o link é: https://aurelio.net/regex/.

Exemplo:

Código: Selecionar todos

    ^ = inicio de paragrafo;
    $ = final de paragrafo;
    
    () = grupos;
    
    [A-Z] = caracteres maiusculos;
    [a-z] = caracteres minusculos;
    [0-9] = digitos;
    ... $*&@# = demais caracteres;
    {n,N} = quantidades - exemplo: {8,15} minimo 8 caracteres, maximo 15

Obrigado pela contribuição!

Att.
Mauricio Portela

[JoséQuintas]

Mas depende de versão.
Tem relato sobre mudanças entre versões, se não me engano no próprio harbour.

Só mexi com isso quando configurei PNOTEPAD.

Código: Selecionar todos

--langdef=harbour
--langmap=harbour:.prg.ch.hbp.hbc.hbm.img
--regex-harbour=/^(PROCEDURE|STATIC PROCEDURE)[ ]*([a-zA-Z0-9_]+)/\2/p,harbour/i
--regex-harbour=/^(FUNCTION|STATIC FUNCTION) ]*([a-zA-Z0-9_]+)/\2/f,harbour/i
--regex-harbour=/^(CREATE CLASS)[ ]*([a-zA-Z0-9_]+)/\2/c,harbour/i
--regex-harbour=/^(METHOD|MESSAGE)[ ]*([a-zA-Z0-9_]+)/\2/m,harbour/i
--regex-harbour=/\b(  DATA|VAR|CLASS VAR)[ ]+([a-zA-z0-9_]+)/\2/d,harbour/i
--regex-harbour=/#(define|command|translate|xcommand|xtranslate)[ ]*([a-zA-Z0-9_]+)/\2/s,harbour/i
--regex-harbour=/\b(MEMVAR|PRIVATE|PUBLIC)[ ]+([a-zA-Z0-9_]+)/\2/v,harbour/i
--regex-harbour=/\b(MEMVAR|PRIVATE|PUBLIC)[ ]+([a-zA-Z0-9_]+), \b([a-zA-Z0-9_]+)/\3/v,i
--regex-harbour=/\b(MEMVAR|PRIVATE|PUBLIC)[ ]+([a-zA-Z0-9_]+), \b([a-zA-Z0-9_]+), \b([a-zA-Z0-9_]+)/\4/v,harbour/i
--regex-harbour=/\b(MEMVAR|PRIVATE|PUBLIC)[ ]+([a-zA-Z0-9_]+), \b([a-zA-Z0-9_]+), \b([a-zA-Z0-9_]+), \b([a-zA-Z0-9_]+)/\5/v,harbour/i
--regex-harbour=/\b(MEMVAR|PRIVATE|PUBLIC)[ ]+([a-zA-Z0-9_]+), \b([a-zA-Z0-9_]+), \b([a-zA-Z0-9_]+), \b([a-zA-Z0-9_]+), \b([a-zA-Z0-9_]+)/\6/v,harbour/i
--regex-harbour=/\b(MEMVAR|PRIVATE|PUBLIC)[ ]+([a-zA-Z0-9_]+), \b([a-zA-Z0-9_]+), \b([a-zA-Z0-9_]+), \b([a-zA-Z0-9_]+), \b([a-zA-Z0-9_]+), \b([a-zA-Z0-9_]+)/\7/v,harbour/i
--regex-harbour=/\b(MEMVAR|PRIVATE|PUBLIC)[ ]+([a-zA-Z0-9_]+), \b([a-zA-Z0-9_]+), \b([a-zA-Z0-9_]+), \b([a-zA-Z0-9_]+), \b([a-zA-Z0-9_]+), \b([a-zA-Z0-9_]+), \b([a-zA-Z0-9_]+)/\8/v,harbour/i
--regex-harbour=/\b(MEMVAR|PRIVATE|PUBLIC)[ ]+([a-zA-Z0-9_]+), \b([a-zA-Z0-9_]+), \b([a-zA-Z0-9_]+), \b([a-zA-Z0-9_]+), \b([a-zA-Z0-9_]+), \b([a-zA-Z0-9_]+), \b([a-zA-Z0-9_]+), \b([a-zA-Z0-9_]+)/\9/v,harbour/i

Com base nesssa configuração, ele pega isto:

Mas já não lembro mais nada.
Faz muito tempo.