Option Explicit forces you to declare all variables before usingthem. Opinions vary greatly on this subject. The main reason to use the OPTION EXPLICIT statement at the top of all modules is to minimize the amount of bugs introduced into your code by misspelling a variable name. Most variants of BASIC (including VB) have the capability to create variable 'on the fly' (without any clarations).This capability can be a double edged sword.

The OPTION EXPLICIT statement causes VB to 'disable' its ability to create variables on the fly. Thus, all variables must be declared using a DIM or REDIM statement. All variables not declared will cause an error when the OPTION EXPLICIT statement is used. This will eliminate bugs caused by a misspelled variable. The option works module-wide,so you can have some modules with and some without this option in your project. Declaring variables "on the fly" makes all but the most trivial code difficult to debug and maintain.

VB creates Variant type variables by default.

For more visit :

http://www.mckisicsoftwar e.com/Resources/visual_basic_f aqs.htm#q_2

Answered by Ashish Yadav , an ibibo Wizard, at 5:07 PM on September 19, 2008

well,Option Explicit forces you to declare all variables before using
them. Opinions vary greatly on this subject. The main reason to
use the OPTION EXPLICIT statement at the top of all modules is to
minimize the amount of bugs introduced into your code by
misspelling a variable name. Most variants of BASIC (including VB)
have the capability to create variables 'on the fly' (without any
declarations). This capability can be a double edged sword.

At the minimum, some suggest using the DEFINT A-Z statement in leu
of OPTION EXPLICIT. This statement will cause any variables which
are created on the fly to be created as integers as opposed to
variant (VB 3.0) or single precision (VB 1.0 and 2.0). (Integers
take up less memory).

The OPTION EXPLICIT statement causes VB to 'disable' its ability
to create variables on the fly. Thus, all variables must be
declared using a DIM or REDIM statement. All variables not
declared will cause an error when the OPTION EXPLICIT statement is
used. This will eliminate bugs caused by a misspelled variable.
The option works module-wide, so you can have some modules with
and some without this option in your project.
source:www.faqs.org/ faqs/visual-basic-faq/windows/

Answered by Debashis , an ibibo Master, at 10:58 AM on September 19, 2008

escription

Used at script level to force explicit declaration of all variables in that script.

Syntax

Option Explicit

Remarks

If used, the Option Explicit statement must appear in a script before any procedures.

When you use the Option Explicit statement, you must explicitly declare all variables using the Dim, Private, Public, or ReDim statements. If you attempt to use an undeclared variable name, an error occurs.
Tip Use Option Explicit to avoid incorrectly typing the name of an existing variable or to avoid confusion in code where the scope of the variable is not clear.

Answered by Sharad Singh , an ibibo Master, at 6:02 PM on September 18, 2008

Option Explicit forces you to declare all variables before usingthem. Opinions vary greatly on this subject. The main reason to use the OPTION EXPLICIT statement at the top of all modules is to minimize the amount of bugs introduced into your code by misspelling a variable name. Most variants of BASIC (including VB) have the capability to create variable 'on the fly' (without any clarations).This capability can be a double edged sword.

The OPTION EXPLICIT statement causes VB to 'disable' its ability to create variables on the fly. Thus, all variables must be declared using a DIM or REDIM statement. All variables not declared will cause an error when the OPTION EXPLICIT statement is used. This will eliminate bugs caused by a misspelled variable. The option works module-wide,so you can have some modules with and some without this option in your project. Declaring variables "on the fly" makes all but the most trivial code difficult to debug and maintain.

VB creates Variant type variables by default.

Answered by Hem@nt .... , an ibibo Master, at 2:14 PM on September 18, 2008

Well, Option Explicit Statement (Visual Basic) Forces explicit declaration of all variables in a file.

Parts

On

Optional. Enables Option Explicit checking. If On or Off is not specified, the default is On.

Off

Optional. Disables Option Explicit checking.

Remarks

If used, the Option Explicit statement must appear in a file before any other source code statements.

When Option Explicit appears in a file, you must explicitly declare all variables using the Dim or ReDim statements. If you attempt to use an undeclared variable name, an error occurs at compile time.

Use Option Explicit to avoid incorrectly typing the name of an existing variable or to avoid confusion in code where the scope of the variable is not clear. If you do not use the Option Explicit statement, all undeclared variables are of Object type.

You can also set Option Explicit in the Visual Studio integrated development environment (IDE) or on a command line.
To set Option Explicit in the integrated development environment (IDE)

1.

On the Tools menu, choose Options.
2.

Open the Projects and Solutions node.
3.

Choose VB Defaults.
4.

Modify the Option Explicit setting.

To set Option Explicit on the command line

*

Include the /optionexplicit compiler option in the vbc command.

Example

The following example uses the Option Explicit statement to force explicit declaration of all variables. Attempting to use an undeclared variable causes an error at compile time.
Visual Basic


' Force explicit variable declaration.
Option Explicit On

Visual Basic

Dim thisVar As Integer
thisVar = 10
' The following assignment produces a COMPILER ERROR because
' the variable is not declared and Option Explicit is On.
thisInt = 10 ' causes ERROR

For more details , Please visit the source site :

http://msdn.microsoft.com/en-u s/library/y9341s4f(VS.80).aspx

Answered by Alok Gupta , an ibibo Guru, at 10:52 AM on September 18, 2008

well;
When writing your ASP pages, there is one very important step many developers unfortunately forget to do or in some cases are too lazy to do. Always put the effort in and avoid writing sloppy code, use Option Explicit.

Option Explicit requires that all variable names be declared (with the Dim statement). Using Option Explicit to force variable declaration is good for a number of reasons. First, let's look at this code example:

<%
MyName = "michael"
Response.Write(MyNa m)
%>

As I have mispelt MyName and written MyNam nothing will be printed out, ASP will create a new variable MyNam and assign an empty string to it. If your code is long then finding this typing mistake can take you hours.Trust me!!

<%
Option Explicit 'Always, always, always!
'declare your variables
Dim MyName
MyNam = "Michael"
Response.Write(MyNa me)
%>

Note that If you write the code in the style above using Option Explicit you will get an ASP error informing you that MyNam is undefined. You must first use the Dim statement. Debugging becomes alot easier!

Below is a section of code with an example of a spelling mistake. We have declared our variables but unfortunately mispelled one of our variables ie MyNam. Using Option Explicit the undefined variable will be picked up and the error message 'Variable is undefined' will be displayed. This can truely save you an awful lot of time when debugging your code.

Just note that the Option Explicit must come before any HTML code.

<%@ Language="VBScript" %>
<% Option Explicit %>
<html>
<head>
<title>Usi ng Option Explicit</title>
</head>

< body>

<%
'declare your variables
dim MyName, MyAddress, MyfootballTeam
MyNam = "michael"
Response.Write(MyNa me)
MyAddress = "16 Marki Street"
Response.Write(MyAddr ess)
MyfootballTeam ="Spurs"
Response.Write(Myfoo tballTeam)
%>
</body>
</htm l>

Answered by Kishore , an ibibo Master, at 7:50 AM on September 18, 2008

I'm not all that against VB.NET, but I'll be honest -- I normally cringe when going to a client site that uses it exclusively. The reasons are many and varied, but most of the time my fears are groundless... But one thing that gives me night terrors is seeing VB.NET projects with Option Strict not turned on.

Back in the days of VB6, those people wishing to write second-rate and error-prone code had the nifty switch called “Option Explicit” - To simplify it, we'll say it's a compiler switch that said “Error the compile if variables aren't explicitly declared before use”. It stopped you from saying Dim Abcde as Integer on one line, and DoSomething(Abce) on another. I can't tell you the number of times I'd get handed code, turn Option Explicit on in a file and immediately have the build break. Yikes! Never once was there an acceptable reason to do this. (One person did start in on performance nit-picks - don't let me get started).

The best part was that the great (no sarcasm, VB6 was, and a great tool for many purposes) people who brought us VB6 turned the option off by default for what I imagine was compatibility reasons. So most people never turned it on, and many of them turned out poor-quality code (I don't know what's cause and what's effect here, did great developers turn it on, or did turning it on make developers great? My bet is more the latter than the former, but I'm sure it helped to catch errors at compile-time)

Now we have Option Strict ( I don't need to explain all of what it does, this is the web - I link ) Which restricts implicit type conversions. It also verifies that functions have return types and all paths return a value -- all things that that the C# compiler always verifies. It's a performance helper(by elimitating hidden type conversions), catches lots of possible errors, and is generally a must... but again, it's off by default (AAARGH!). I'm sure the reasons for that are many and good, but.... AAARGH.

Why is it a must? Well, I've been fixing lots of code, and here's something I must have fixed four times, just this week - a bug that can be very subtle and hard to track down without Option Strict.

Public Function Something(Arg1 as AnEnumType) As SomeObject
Select Case Arg1
Case AnEnumType.A
Return New SomeObject(1)
Case AnEnumType.B
Return New SomeObject(2)
Case AnEnumType.B
Return New SomeObject(3)
End Select
End Function

Why is this bad? Well, what if I add a new enum to AnEnumType, say AnEnumTypeD... what gets returned? Nothing, that's what. And when you just know that a code path has to return an object this can be fun to track down. There are lots of other cases where this happens, involving catch blocks that don't rethrow but cause the return to be skipped, If's with no Else's, and so on, but they're all bad.

So please, code with Option Strict on -- if you start with it off, it can be hell to go “strict-ify” your code later. Us poor slobs who have to add features later will sure appreciate it.

Taken from-
http://weblogs.asp.net/ prieck/archive/2003/10/21/3286 9.aspx

Answered by Nagendra , an ibibo Master, at 6:13 AM on September 18, 2008

Option Explicit forces the programmer to declare all variables, rather than letting them be implicitly declared upon their first use. This enforces good programming practices and avoids ambiguity of variable scope.
Here are some simple code examples:
'*********************** **************
i = 1
Call mySub
WScript.Echo i

Sub mySub
i = 10
End Sub
'***************************** ********
In this first example, because the programmer is relying on
implicit variable declaration, the subroutine is modifying
global variable i, and the printed result is 10. Now, modify
the code so that the variables are declared:
'*********************** **************
dim i
i = 1
Call mySub
WScript.Echo i

Sub mySub
dim i
i = 10
End Sub
'***************************** ********
Now, we actually have two different variables named i, one
with global scope, and one with local scope. The printed
result is now 1.
Since a lot of programmers use i in For..Next loops, you can
see how this could result in unpredictable results without
explicit variable declaration

http://www.allinterv iew.com/showanswers/12856.html

Answered by Dan !!!!!! , an ibibo Specialist, at 5:26 AM on September 18, 2008

hi,friend
Option Explicit forces you to declare all variables before usingthem. Opinions vary greatly on this subject. The main reason to use the OPTION EXPLICIT statement at the top of all modules is to minimize the amount of bugs introduced into your code by misspelling a variable name. Most variants of BASIC (including VB) have the capability to create variable 'on the fly' (without any clarations).This capability can be a double edged sword.

The OPTION EXPLICIT statement causes VB to 'disable' its ability to create variables on the fly. Thus, all variables must be declared using a DIM or REDIM statement. All variables not declared will cause an error when the OPTION EXPLICIT statement is used. This will eliminate bugs caused by a misspelled variable. The option works module-wide,so you can have some modules with and some without this option in your project. Declaring variables "on the fly" makes all but the most trivial code difficult to debug and maintain.

VB creates Variant type variables by default.

Answered by Nz , an ibibo Master, at 2:52 AM on September 18, 2008