Attention: We are retiring the ASP.NET Community Blogs. Learn more >

Contents tagged with Regex

  • Fred : Lazy or just plain Greedy?

    No Comments

    The question of greediness and backtracking has come up around here quite a bit of late - as they are the essence of what regex is all about - and, while I don't plan on ranting about either just now, it's worth a reminder as to what can cause backtracking can occur.

    Read more...

  • Issues with a lambda expression

    No Comments

    In javascript you can use a function to as an argument to the string.replace function when matching against a regex pattern - this is often referred to as a lambda expression.  For example, in the following piece of code, the function is invoked for each match.  The result is that the letters in the word "foo" are alerted in sequence:

    Read more...

  • Regex Reminders [1] - Replacement Operations

    11 Comments

    A common application for regular expressions is to find and replace strings within a body of text. These operations range from something as simple as finding some text and removing it to locating and re-writing Hmtl tags. Let's take a quick look at the signatures of the .NET Regular Expression Replace overloads.

    Read more...

  • Regex Reminders #0 - Commenting Regular Expressions

    10 Comments 

    Free spacing and comment mode
    .NET Regular Expressions allow you to embed comments and whitespace within pattern strings making them clearer to 
    read (because of the whitespace), and easier to maintain (due to the modularity).

To use this feature you must turn on the RegexOptions.IgnorePatternWhitespace flag.  This can be achieved 
    either by using the RegexOptions enumerated datatype or, via the (?x) mode modifier.  Therefore the following 
    two examples are functionally identical:


    Regex re = new Regex( 
        @"           # This pattern matches Foo
            (?i)     # turn on insensitivity
                     # The Foo bit
            \b(Foo)\b "
        , RegexOptions.IgnorePatternWhitespace ) ;


    Regex re = new Regex( 
        @"(?x)
                    # This pattern matches Foo
            (?i)    # turn on insensitivity
                    # The Foo bit
            \b(Foo)\b "
        ) ;


Using IgnorePatternWhitespace option, comments can be embedded in one of two ways.  Firstly, a raw '#' 
    character can be used to mark the beginning of a comment and the comment runs up to the first NEWLINE 
    (\n) character that is encountered.  This can be easily achieved in C# with verbatim strings @"..." 
    or in VB by appending newline characters within the string using Chr(10), vbCrLf or Environment.NewLine.  
    Comments can also be declared using the (?#...) syntax.

The following 3 snippets demonstrate examples of each of these methods...


C# Verbatim Strings.


    using System;
    using System.Collections;
    using System.Text.RegularExpressions ;

    namespace Regex Snippets.Tests
    {
        public class CommentedCSharp
        {
            public static void Main()
            {
                Regex re = new Regex( 
                    @"           # This pattern matches Foo
                        (?i)     # turn on insensitivity
                                 # The Foo bit
                        \b(Foo)\b "
                , RegexOptions.IgnorePatternWhitespace ) ;
        
                for ( Match m = re.Match( "foo bar Foo" ) ; m.Success ; m = m.NextMatch() )
                    Console.WriteLine( m.Value + Environment.NewLine ) ;
                
                Console.ReadLine();
            }
        }    
    }



VB.NET using (?#...) syntax.


    Option Strict On

    Imports System.Text.RegularExpressions


    Namespace Regex Snippets.Tests

        Module CommentedVBOne

            Public Sub Main()

                ' Demonstrates a VB Whitespace pattern using the 
                '" (?#...) " & _
                ' syntax
                Dim re As New Regex( _
                        "                   (?# This pattern matches Foo ) " & _
                        "  (?i)             (?# turn on insensitivity ) " & _
                        "                   (?# The Foo bit ) " & _
                        "  \b(Foo)\b " _
                    , RegexOptions.IgnorePatternWhitespace)

                Dim m As Match = re.Match("foo bar foo")
                Dim s As String = ""

                While m.Success
                    s &= (m.Value & Environment.NewLine)
                    m = m.NextMatch()
                End While
                MessageBox.Show(s)
            End Sub

        End Module

    End Namespace



VB.NET using appended newlines.


Option Strict On

    Imports System.Text.RegularExpressions


    Namespace Regex Snippets.Tests

        Module CommentedVBTwo

            Public Sub Main()

                ' Demonstrates a VB Whitespace pattern using the 
                '" (?#...) " & _
                ' syntax
                Dim re As New Regex( _
                        "                 # This pattern matches Foo " & vbCrLf & _
                        "  (?i)           # turn on insensitivity " & vbCrLf & _
                        "                 # The Foo bit " & vbCrLf & _
                        "  \b(Foo)\b " _
                        , RegexOptions.IgnorePatternWhitespace)

                Dim m As Match = re.Match("foo bar foo")
                Dim s As String = ""

                While m.Success
                    s &= (m.Value & Environment.NewLine)
                    m = m.NextMatch()
                End While
                MessageBox.Show(s)
            End Sub

        End Module

    End Namespace

    Read more...