Solution

The way to do this is as Phil suggested; but with a few (small) modifications:

RewriteEngine On
RewriteCond %{QUERY_STRING}  substring=returns?  [NC]
RewriteRule  . /catalog/Returns.html? [L]
RewriteCond %{QUERY_STRING}  substring=shipping  [NC]
RewriteRule  . /catalog/Shipping.html? [L]

N.B. In the event you only want to remove one parameter see the Additional Information and Explanations below.

N.B. For more strict matching see Where & becomes a problem below.

Explanation

Background

The best way for me to explain the difference (between the above and Phil's original) and why you were having a problem is to explain what is going on...

RewriteCond %{QUERY_STRING} substring=returns? [NC] checks the query string for instances of the regex that follows it in this case substring=returns?*.

The [NC] flag simply means to match upper and lower case letters.

*Clarification: The regex(substring=returns?) means substr=return is matched literally with or without an s.

Problem

If the condition is met (i.e. the regex pattern is matched in the query string) then the rewrite rule is triggered. This is where the problem lies...

Given the URL: http://example.com/?substring=returns

The original rule:

RewriteRule  . /catalog/Returns.html [L]

Rewrites the URL leaving the query string in place, like so:

http://example.com/?substring=returns
http://example.com/catalog/Returns.html?substring=returns
http://example.com/catalog/Returns.html?substring=returns
http://example.com/catalog/Returns.html?substring=returns
http://example.com/catalog/Returns.html?substring=returns
...and so on until limit is reached...

Side note: The [L] flag stops the .htaccess file from going through any more rules but it doesn't stop it looping again.

Solution

The solution then is to overwrite the query string (since we no longer need it) you can do this simply by adding a ? to the end of the RewriteRule:

RewriteRule  . /catalog/Returns.html? [L]

N.B. In the event you only want to remove one parameter see the Additional Information and Explanations below.

N.B. For more strict matching see Where & becomes a problem below.

Resources

The following resources may come in helpful in the future:

.htaccess flags

http://httpd.apache.org/docs/current/rewrite/flags.html

Regular expressions

http://www.regular-expressions.info/ - Check out the tutorials section

Additional Information and Explanations

Where & becomes a problem

RewriteCond %{QUERY_STRING}  &substring=returns?  [NC]

In the above the regex means to match the characters &substring=return with an optional s appended to it.

So it would match the following as expected:

http://example.com/?var1=somvalue&substring=return
http://example.com/?var1=somvalue&substring=returns
http://example.com/?var1=somvalue&substring=return&var2=othervalue
http://example.com/?var1=somvalue&substring=returns&var2=othervalue

Which is fine and given the original query string wouldn't be a problem, however, if I were to navigate to the page and write in the parameters in a different order, the & wouldn't necessarily be there and therefore it wouldn't match (when it should):

http://example.com/?substring=return&var1=somevalue
http://example.com/?substring=returns&var1=somevalue

Simply getting rid of it (as I did) would solve this problem, but it doesn't come risk free.

RewriteCond %{QUERY_STRING}  substring=returns?  [NC]

If you were to introduce a new parameter secondsubstring for example it would match when it shouldn't:

Good Match > http://example.com/?substring=return&var1=somevalue
Good Match > http://example.com/?var1=somevalue&substring=return
Bad  Match > http://example.com/?secondsubstring=return&var1=somevalue

To solve this potential issue you could do the following:

RewriteCond %{QUERY_STRING}  ^(.*&)?substring=returns?

The above will match:

http://example.com/?substring=return&var1=somevalue
http://example.com/?var1=somevalue&substring=return

But won't match:

http://example.com/?secondsubstring=return&var1=somevalue

One more potential problem is that the expression would match:

http://example.com/?substring=returning&var1=somevalue
http://example.com/?substring=return%20television&var1=somevalue

My understanding, again, is that this wouldn't be a problem in the given situation. However if it were to be a problem you could do:

RewriteCond %{QUERY_STRING}  ^(.*&)?substring=returns?(&|$)

The above checks that the character following return/returns is either an & signalling the end of the variable and the start of a new one or the end of the query string.

Rewriting one parameter

In some circumstances as Phil pointed out it may be preferable to only remove one parameter at a time and leave the rest of the query string untouched.

You can do this, quite simply, by implementing capture groups in the RewriteCond and outputting them in the RewriteRule:

RewriteCond %{QUERY_STRING}  ^(.*&)?substring=returns?(&.*)?$  [NC]
RewriteRule  . /catalog/Shipping.html?%1%2 [L]

Rewrite explanation

You use %N to insert capture groups from the rewrite condition and $N to insert capture groups from the rewrite rule.

So in this case we redirect to:

/catalog/shipping.html?(RewriteCond Group1)(RewriteCond Group2)
/catalog/Shipping.html?%1%2

The [L] flag - as previously - stops the processing of any rules further down the .htaccess file

Regex explanation

^(.*&)?substring=returns?(&.*)?$

• ^ Start of string
• (.*&)? First capture group
  • Capture any character . 0 or more times *
  • Followed by an &
  • The ? makes the entire group optional
• substring=returns? Matches substring=return literally with an optional s
• (&.*)? Second capture group
  • Capture an &
  • Capture any character . 0 or more times *
  • The ? again makes the group optional
• $ End of string

[L] flag vs [END]

For completeness sake...

The [L] flag stops the .htaccess from going over any more rules further down the .htaccess file.

The [END] flag stops the rewrite process completely.

To illustrate with an example:

while(TRUE){
    if(condition1){ continue; }
    if(condition2){ continue; }
    if(condition3){ continue; }
    if(condition4){ continue; }
}


while(TRUE){
    if(condition1){ break; }
    if(condition2){ break; }
    if(condition3){ break; }
    if(condition4){ break; }
}

In the above code blocks the [L] flag acts like a continue statement in that it skips the rest of the code block and starts again. Whilst the [END] flag acts as a break statement and stops the loop entirely.

If we were to replace the [L] flag with [END] in Phil's original answer then it would work. With the caveats mentioned in the Where & becomes a problem section above.

RewriteEngine On
RewriteCond %{QUERY_STRING}  &substring=returns?  [NC]
RewriteRule  . /catalog/Returns.html [L]
RewriteCond %{QUERY_STRING}  &substring=shipping  [NC]
RewriteRule  . /catalog/Shipping.html [L]

etc.

Would something like that do the job for you? Note that 'returns?' means 'return' or 'returns'. Are you limited to one search term at a time, or might customers type in a phrase? I think & is safe to use there, but it's possible it's not.

Don't forget to do this stuff ahead of any commands to rewrite Returns.html to Returns.php, do SEO, etc.