Tjekke streng igennem uden Regex

"Indeholder" eller "kun indeholder"? I det første tilfælde må strengen godt indeholde andet.

du kan jo altid bruge en for løkke

men formentlig vil regex give dig den pæneste kode som er nemmest at ændre

string Tekst = "Er der en funktion i c#, så man kan tjekke om en streng indeholder tal fra 0-9??";

bool IndeholderTegn = false;
for (char Tegn='0'; Tegn<='9'; Tegn++)
{
    if (Tekst.IndexOf(Tegn) >= 0)
    {
        IndeholderTegn = true;
        break;
    }
}

if (IndeholderTegn)
    Console.WriteLine("Indeholder et af tal-tegnene.");
else
    Console.WriteLine("Indeholder ikke et af tal-tegnene.");

Det jeg gerne vil undgå er at, man kan skrive Al6x...

Er det 6-taller som er ulovligt? Eller de tre punktummer eller hvad?

Der hvor man skal skrive sit navn, må man ikke skrive andet end bogstaver. Ingen symboler eller tal

Så er det nu nemmest med en RegEx - er der nogen speciel grund til at du ikke ønsker at bruge sådan en?

Næ det er der nu ikke. Det kunne bare godt være, at det kunne lade sig gøre uden

Det kan det da sagtens, men koden bliver bare mere omfattende. Du kan jo selv dømme:

using System;
using System.Text.RegularExpressions;

namespace e659313
{
    class Class1
    {
        [STAThread]
        static void Main(string[] args)
        {
            string Tekst = "Er der en funktion i c#, så man kan tjekke om en streng indeholder tal fra 0-9??";

            MedRegex(Tekst);
            UdenRegex(Tekst);
        }

        static void MedRegex(string Tekst)
        {
            Regex RE = new Regex("^[a-zæøå]+$", RegexOptions.IgnoreCase);
            if (RE.Match(Tekst).Success)
                Console.WriteLine("Lovlig");
            else
                Console.WriteLine("Ikke lovlig");
        }

        static void UdenRegex(string Tekst)
        {
            bool Lovlig = true;
            for (int index=0; index<Tekst.Length; index++)
            {
                char Tegn = Tekst[index];
                if (('a' <= Tegn && Tegn <= 'z') ||
                    (Tegn == 'æ') || (Tegn == 'ø') || (Tegn == 'å') ||
                    ('A' <= Tegn && Tegn <= 'Z') ||
                    (Tegn == 'Æ') || (Tegn == 'Ø') || (Tegn == 'Å'))
                {
                    // Et lovligt tegn.
                }
                else
                {
                    Lovlig = false;
                    break;
                }
            }

            if (Lovlig && (Tekst != ""))
                Console.WriteLine("Lovlig");
            else
                Console.WriteLine("Ikke lovlig");
        }
    }
}

Smid et svar nielle:) Havde godt nok tænkt på den sidste metode uden regex, men synes ikke det er så pænt. Så det bliver med regex. Og tak

Svar :^)

nielle>

Jeg synes ikke at din uden regex kode er pænest muligt.

using System;
using System.Text.RegularExpressions;

namespace E
{
    class MainClass
    {
        private static Regex re = new Regex("^[A-Za-zÆØÅæøå]*$");
        public static bool AllText1(string s)
        {
            return re.Match(s).Success;
        }
        private static string valid = "ABCDEFGHIHKLMNOPQRSTUVWXYZÆØÅ" +
                                      "abcdefghijklmnopqrstuvwxyzæøå";
        public static bool AllText2(string s)
        {
            for(int i = 0; i < s.Length; i++)
            {
                if(valid.IndexOf(s[i]) < 0)
                {
                    return false;
                }
            }
            return true;
        }
        public static void Test(string s)
        {
            Console.WriteLine(AllText1(s));
            Console.WriteLine(AllText2(s));
        }
        public static void Main(string[] args)
        {
            Test("ABC");
            Test("123");
            Test("A1");
        }
    }
}

"Pænest muligt" er jo sådan set et subjektivt begreb - personligt er jeg nu godt tilfreds.

Du laver dine funktioner sådan at de returnere bool'ske værdier og det spare selvføgeligt på linjerne - og selv om dette jo sådan set ikke noget at gøre med selve algoritmen - så får I den alligevel i "samme" udgave:

static bool UdenRegex(string Tekst)
{
    for (int index=0; index<Tekst.Length; index++)
    {
        char Tegn = Tekst[index];
        if (!(('a' <= Tegn && Tegn <= 'z') || (Tegn == 'æ') || (Tegn == 'ø') || (Tegn == 'å') ||
              ('A' <= Tegn && Tegn <= 'Z') || (Tegn == 'Æ') || (Tegn == 'Ø') || (Tegn == 'Å')))
            return false;

        return true;
    }
}

pointen er ikke så meget bool versus Console.WriteLine (eller for den sags skyld
{} versus ikke {})

pointen var at hive de valide tegn ud i en liste

Jeg er godt klar over hvad du mener - det var det jeg skrev ang. algoritmen. Det kan bare være svært for det utrænede øje at abstrahere fra den slags ting; Derfor min alternative kode som lå tættere op af din form. :^)

Vi har bare valgt at angibe problemet fra hver sin ende - og jeg synes stadig godt at jeg kan være mit forslag bekendt.

sagtens

jeg ville bare lige nævne at jeg synes at IndexOf giver lidt pænere kode