[Jaey]

Is there a way, in perl, to check to see if a string or variable is the same as an element in an array?
Something like:

Code:
$foo="cheese";
@bar=qw(milk beef cheese salad);
if ($foo is in @bar)
{
print "Happy!";
}

I can do it easily with a loop, but that seems like a lot of work for such a simple thing...

[absmiths]

Originally posted by Jaey:
I can do it easily with a loop, but that seems like a lot of work for such a simple thing...

I am not that familiar with Perl, but looping to identify an element in an array is the most common approach (and the method the perl interpreter would employ even if it does have a shorthand way), so I would just go with that.

[larkost]

*knuckles crack*

Code:
$foo="cheese";
%thisHash = ("milk", "beef", "cheese", "salad");
if (exists(%thisHash->{$foo})) {
    print "Happy!";
}

Ahh.. the wonders of hash arrays....

Plus, they are generally close to O:log(n) in operation, so you can have a lot of items and they are still efficient.

[Jaey]

Originally posted by larkost:
Plus, they are generally close to O:log(n) in operation, so you can have a lot of items and they are still efficient. [/B]

O:log(n)?




I didn't even think of hash arrays... that helps alot, thanks.

[Basilisk]

Hashes are the best solution if you are not concerned with array order or are concerned with performance for a large number of items. If you just need a single check in a one-off script this will work just as well:

$foo="cheese";
@bar=qw(milk beef cheese salad);
if (grep {$_ eq $foo} @bar)
{
print "Happy!";
}

[larkost]

Jaey: O:log(n) is a computer science term: it refers to "Big O" notation. This is a concept that tries to predict how long a process will take in very broad strokes by looking at how the program loops.

To give a simple intro into Big O with this as an example:

If you were to use the method that absmiths suggests you would have to go through every item of your array for every item you are checking. If either list gets long, this process can get very long. This is called worst case O:n (since in the worst case you will have to go through them item in the list: n).

In the case of a hash array the speed scales well below O:n, it is close to the natural log of n, so it is called O:log(n).

On short lists O:log(n) can be slightly slower than O:n, but with big lists it is much, much faster. So get into the habit of using O:log(n) algorithms whenever possible. In this specific case, it will probably be faster for short or long lists, as perl has a very efficient hash algorithm built in.

[asidrane]

Big-O notation doesn't apply to just comp-sci. It is a mathematical term found in discrete math

[larkost]

The concept should apply to any iterative process... even to folding the laundry. But it usually only gets useful when a computer is involved, since computers are so good at dong things over and over again.

[qyn]

Originally posted by larkost:

Code:
$foo="cheese";
%thisHash = ("milk", "beef", "cheese", "salad");
if (exists(%thisHash->{$foo})) {
    print "Happy!";
}

Apparently no one has noticed this code doesn't actually work. Defining a hash this way is really setting the key-value pairs, such that:

milk => 'beef'
cheese => 'salad'

The exists() command tests for the presence of a key in the hash. Since "cheese" and "milk" are keys, this works. But it will not work for "beef" or "salad". (Try it.)

Basilisk's solution is really the proper way.

If you were planning on doing this many times, you would really want to make a hash since that'll be faster than a sequential search each time. But it has to be a hash where all your words are keys. So this code would work using a hash:

Code:
%thisHash = map{($_, 1)}("milk", "beef", "cheese", "salad");
if (exists(%thisHash->{$foo})) {
    print "Happy!";
}

The map function is a fancy way of making the hash:

milk => 1
beef => 1
etc.

So all your words are keys, the exists() test works, and we're all "Happy!"