Check om string er numerisk, alfabetisk osv

Du kan bruge regex.

Du kan prøve at parse og catche en exception.

Du kan lave en manuelt gennemløb af strengen.

Løsning 2:

    public static bool IsDigit(string s)
    {
        try
        {
            int tmp = int.Parse(s);
            return true;
        }
        catch(FormatException)
        {
            return false;
        }
    }

Løsning 1:

    private static Pattern p = Pattern.compile("

• ?[0-9]+");
  

    private static boolean intCheck(String s) {
        return p.matcher(s).matches();
    }

En for løkke som løber strengen igennem og tester hver tegn behøver jeg vist ikke
vise.

Hvad med check om den er alfabetisk eller alfanumerisk?
Og vil en for lykke ikke være rimelig sløvt hvis den ska checke ca. 10000 strings igennem som hver er på op til 50 karakterer.
Jeg tror en Regex vil være bedre, men som sagt har jeg ikke så meget styr på det emne, jeg har leget lidt med det, men kunne ikke finde en løsning der virkede.

Jeg bør måske lige forklare hvorfor det er vigtigt at vide om det er numerisk, alfabetisk eller alfanumerisk.
Jeg er ved at lave en converter til EDIFACT data, i det data format er der strenge regler for hvordan data må være udformet, heriblandt skal der checkes om hver data streng består af numerisk, alfabetisk eller alfanumerisk data, og da det er en meget streng standard SKAL dette checkes.

Du kan være ret sikker på at regex er langsommere end din egen for løkke !

[0-9]+
[A-Za-z]+
[A-Za-z0-9]+

må vel være 3 gode regex udtryk

[0-9]+ og [A-Za-z]+ vil begge være sande ved alfanumerisk, så de dutter ik helt, regex udtrykket ska på en måde udelukke alfabetiske tegn i strengen der checker om den er numerisk, og omvendt.

Nej.

[0-9]+ ville ikke matche en hel streng som indeholder bogstaver og tal
(men kan selvfølgelig godt matche en del af strengen).

Følgende kode giver dette resultat:

Checking: 412132
String is numeric
String is alphanumeric
Checking: asdasdgfa
String is alphabetic
String is alphanumeric
Checking: asgagf134151
String is numeric
String is alphabetic
String is alphanumeric

---------------------------

using System;
using System.Text.RegularExpressions;

namespace regextest
{
    class Class1
    {
        [STAThread]
        static void Main(string[] args)
        {
            RegExTester t = new RegExTester();
            t.CheckString("412132");
            t.CheckString("asdasdgfa");
            t.CheckString("asgagf134151");
            Console.ReadLine();
        }
    }

    public class RegExTester
    {
        public void CheckString(string s)
        {
            Console.WriteLine("Checking: " + s);
            if(Regex.IsMatch(s, "[0-9]+"))
                Console.WriteLine("String is numeric");

            if(Regex.IsMatch(s, "[a-zA-ZæÆøØåÅ]+"))
                Console.WriteLine("String is alphabetic");
           
            if(Regex.IsMatch(s, "[a-zA-ZæÆøØåÅ0-9]+"))
                Console.WriteLine("String is alphanumeric");
        }
    }
}

IsMatch tester kun om pattern findes i strengen ikke om den matcher hele strengen.

using System;
using System.Text.RegularExpressions;

namespace regextest
{
    class Class1
    {
        [STAThread]
        static void Main(string[] args)
        {
            RegExTester t = new RegExTester();
            t.CheckString("412132");
            t.CheckString("asdasdgfa");
            t.CheckString("asgagf134151");
            Console.ReadLine();
        }
    }

    public class RegExTester
    {
        public void CheckString(string s)
        {
            Console.WriteLine("Checking: " + s);
            if(Regex.IsMatch(s, "^[0-9]+$"))
                Console.WriteLine("String is numeric");

            if(Regex.IsMatch(s, "^[a-zA-ZæÆøØåÅ]+$"))
                Console.WriteLine("String is alphabetic");
         
            if(Regex.IsMatch(s, "^[a-zA-ZæÆøØåÅ0-9]+$"))
                Console.WriteLine("String is alphanumeric");
        }
    }
}

Checking: 412132
String is numeric
String is alphanumeric
Checking: asdasdgfa
String is alphabetic
String is alphanumeric
Checking: asgagf134151
String is alphanumeric

Eller:

using System;
using System.Text.RegularExpressions;

namespace regextest
{
    class Class1
    {
        [STAThread]
        static void Main(string[] args)
        {
            RegExTester t = new RegExTester();
            t.CheckString("412132");
            t.CheckString("asdasdgfa");
            t.CheckString("asgagf134151");
            Console.ReadLine();
        }
    }

    public class RegExTester
    {
        public void CheckString(string s)
        {
            Console.WriteLine("Checking: " + s);
            if(s.Equals(Regex.Match(s, "[0-9]+").Value))
                Console.WriteLine("String is numeric");

            if(s.Equals(Regex.Match(s, "[a-zA-ZæÆøØåÅ]+").Value))
                Console.WriteLine("String is alphabetic");
         
              if(s.Equals(Regex.Match(s, "[a-zA-ZæÆøØåÅ0-9]+").Value))
                Console.WriteLine("String is alphanumeric");
        }
    }
}

Checking: 412132
String is numeric
String is alphanumeric
Checking: asdasdgfa
String is alphabetic
String is alphanumeric
Checking: asgagf134151
String is alphanumeric

okay, den sidste løsning funker vist, hvis jeg returner resultatet.
Men du mener altså ikke det er den løsning der vil kræve mindst af computeren?

Regular expressions laver en masse "behind the scene".

Det giver minimum af kode at vedligeholde.

Men du bør kunne skrive noget selv som er 2-10 gange hurtigere.

har du et forslag til hvordan det kan opnås, skriv evt. svar på dette som et svar, så får du lidt point

Jeg kan sagtens lave en metod esom checker det.

Men giv mig lige en god halv times tid.

Hunden står og påstår det er tid for aften tur !

hvad bilder den sig ind? :P

using System;
using System.Text.RegularExpressions;

enum StringType { NUMERIC, ALPHABETIC, ALPHANUMERIC, NONE };

class TestClass
{
    public static StringType Check1(string s)
    {
        if(Regex.IsMatch(s, "^[0-9]+$"))
        {
            return StringType.NUMERIC;
        }
        else if(Regex.IsMatch(s, "^[a-zA-ZæÆøØåÅ]+$"))
        {
            return StringType.ALPHABETIC;
        }
        else if(Regex.IsMatch(s, "^[a-zA-ZæÆøØåÅ0-9]+$"))
        {
            return StringType.ALPHANUMERIC;
        }
        else
        {
            return StringType.NONE;
        }
    }
    public static StringType Check2(string s)
    {
        bool dig = false;
        bool let = false;
        bool other = false;
        for(int i = 0; i < s.Length; i++)
        {
            if(Char.IsDigit(s[i]))
            {
                dig = true;
            }
            else if(Char.IsLetter(s[i]))
            {
                let = true;
            }
            else
            {
                other = true;
            }
        }
        if(dig && !let && !other)
        {
            return StringType.NUMERIC;
        }
        else if(!dig && let && !other)
        {
            return StringType.ALPHABETIC;
        }
        else if(dig && let && !other)
        {
            return StringType.ALPHANUMERIC;
        }
        else
        {
            return StringType.NONE;
        }
    }
    private const int N = 1000000;
    public static void Main(string[] args)
    {
        Console.WriteLine(Check1("412132").ToString());
        Console.WriteLine(Check1("asdasdgfa").ToString());
        Console.WriteLine(Check1("asgagf134151").ToString());
        Console.WriteLine(Check1("æblegrød").ToString());
        Console.WriteLine(Check2("412132").ToString());
        Console.WriteLine(Check2("asdasdgfa").ToString());
        Console.WriteLine(Check2("asgagf134151").ToString());
        Console.WriteLine(Check2("æblegrød").ToString());
        long t1 = DateTime.Now.Ticks;
        for(int i = 0; i < N; i++) Check1("Foobar");
        long t2 = DateTime.Now.Ticks;
        for(int i = 0; i < N; i++) Check2("Foobar");
        long t3 = DateTime.Now.Ticks;
        Console.WriteLine("regex : " + (t2 - t1) + " custom : " + (t3 - t2));
    }
}

NUMERIC
ALPHABETIC
ALPHANUMERIC
ALPHABETIC
NUMERIC
ALPHABETIC
ALPHANUMERIC
ALPHABETIC
regex : 147968750 custom : 5781250

Custom løsning er 25 gange hurtigere !

du er en knag, takker for alt hjælpen ;)