You should use the one that uses a module. Namely, RFC::RFC822::Address.

But seriously, why the "no modules" constraint? If you *really* can't use a module, for some bizarre reason, I suggest downloading the module and putting its code in your own source file (take care to heed the copyright notice in the module, though).

Get yourself a copy of RFC 2822. (Don't forget to allow for obsolete addresses; not everyone has read this RFC yet.) If you have access to the O'Reilly book Mastering Regular Expressions, there's a regex in the back of the book that does an incomplete job of checking email addresses, but is about as close as you can get with a plain regex. (Be warned, it's 6598 characters.)

Why don't you want to use a module?

Update: If you want to do email verification by hand, the best advice I can give you is to study RFC 2822 thoroughly. You'll also find Text::Balanced useful for pulling apart the address.

--
The hell with paco, vote for Erudil!
:wq

"Why don't you want to use a module?"

well i like to understand ... not just using somoene's
written module... i'm not trying to write some very short
script ... because it's very practically for me to write
something hard(interesting) myself because it's good ...
it help's inprove'ing my skills.

What's the difference between using a module and copying code someone here gives you then? If you want to understand, just read the module. Reading code also helps improve your skills -- especially if you're going to be doing any serious programming in the future.

While I personally don't mind recreating the occasional wheel, I think this might be a bit much. You'll need to read the RFC and fully understand all of it to determine what you'll need to do. There's a million halfassed ways of doing it (I've been guilty of this myself) but you probably would be better served just using the module and picking a more useful wheel to recreate that will give you the opportunity to learn more than the intimate details of parsing email addresses.

-Lee

"To be civilized is to deny one's nature."

As told by others, you should check the RFC or the module, or the module code. Anyway, if you are reinventing the wheel to learn something new, I'll tell you how I'd do it in the simplest case: address@some.domain.here

First of all, there should be just one "@", and if you want to avoid source routing you should also be sure there are no "%" on the right of the @.

you should check that there actually are characters before the @

top level domain should be two, three or four alphabetical chars (or you should get a list of TLD and check for them; guess how -hint: use an hash).

you should really have something more than only a top level domain on the right of @: a dot must be there, and there should be at least one alphanumeric character (plus the "-") between @ and the dot

Last but not least: no spaces are allowed

So, a regexp could be:

use strict ;
use warnings ;

my @addresses = qw(you@somewhere.com
                   me@here
           me@here@there@everywhere
                   why@
           @.it) ;

foreach (@addresses) {
  print "$_ is " ;
  print /^\S+\@([a-z-]+\.)+[a-z]{2,4}$/ ? "GOOD!!!" : "bad" ;
  print "\n" ;
}
[download]

This yelds:

you@somewhere.com is GOOD!!!
me@here is bad
me@here@there@everywhere is bad
why@ is bad
@.it is bad
[download]

Please remember this is only the simplest case!!!, mail addresses syntax is far more complicated than one would expect reading common addresses. The best way to understand it is to try to write a spam filter for personal use :-)

Have fun!

Ciao!
--bronto

# Another Perl edition of a song:
# The End, by The Beatles
END {
  $you->take($love) eq $you->made($love) ;
}