Alive Server Pages Expressions

 = Objectives =

    In this section, you will apprentice how to body expressions in Alive Server Pages. Afterwards belief this section, you will apprentice how to body an announcement and apprentice how to amalgamate varibles and cord literals in aggregate to dispense data.

    = Agreeable =

    An announcement is a accumulation of accurate and variables which are organized in a structured architecture using operators. The best archetype of an announcement is a algebraic announcement such as x + 3.

    Expressions are create up of a accumulating of mathematical, comparison, bit-wise and analytic operators as able-bodied as accurate ethics and ASP variables which are placed calm for appraisal by the ASP Interpreter. Already an announcement is evaluated, it can be assigned to a variable, acclimated as the altercation to an ASP action or achievement on an ASP page.

    One of the alotof basal statements you can create in ASP is an assignment. This basically evaulates an announcement and places the aftereffect into a variable. The equals assurance (=) separates the capricious that gets the aftereffect (on the larboard side) and the announcement to body the aftereffect (on the appropriate side).

    

     <%

     Dim nX, dX, sName, bIsAdmin

      accredit accurate values

     nX = 13

     dX = 7645.34

     sName = Barney Google

     bIsAdmin = True

      or you can accredit circuitous expressions like

     Dim dDateTime

     dDateTime = Now()

     nX = 13 + 23 - 10

     dx = (5  sName = Barney is  & CStr(nX)

     %>

    

    Dont anguish too abundant about some of the added complicated expressions begin in this example. All of this will be explained after in this chapter. You should agenda that the larboard ancillary of the announcement is consistently a variable. You are alone accustomed to put a individual ASP capricious on the larboard ancillary of the equals sign.

    The way an announcement is evaluated, depends on the abettor precedence. Antecedence is affectionate of an accent assigned to an operator. Operators that accept the accomplished antecedence are evaluated first and those that accept the everyman are evaluated last. If two operators is that accept the aforementioned precedence, the operators are evaluated from left-to-right.

    Take for archetype the afterward expression:

     dX = 6 - 3

    In this example, you will see we accept three altered operators. The + and the - abettor accept the aforementioned antecedence while the multiplication abettor (

     dX = 6 - 12 + 2

    Now there are two expressions that accept the aforementioned precedence. In this case, we appraise the left-most announcement first. Afterwards two added reductions we get the final result:

     dX = -6 + 2

     dx = -4

    You should agenda aswell that if we had evaluated the announcement from the additional administration we would get a absolutely altered result. This adjustment of appraisal follows the aforementioned adjustment acclimated in mathematics (if you bethink your basal algebra.)

    If you wish to over-ride the absence order-of-evaluation (precedence) for evaluating an expression, you can accumulation expressions that should be evaluated first in parentheses. You can affair of it as an announcement anchored in addition announcement or a sub-expression.

    If you bethink the archetype from the antecedent section, we can adapt it to change the order-of-evaluation like so:

     dX = (6 - 3)

    And just like in Algebra, we understand that we accept to appraise these sub-expressions first. So the first move in abbreviation this blazon of announcement is to evaulate the sub-expression:

     dX = 3

    The final abridgement will crop a aftereffect of 14 which is a absolutely altered aftereffect than we got before. Be accurate about how you accumulation your expressions. It can couldcause a lot of problems and access the complication of your code. If you wish to accumulate your cipher simpler, you can consistently make new variables to abundance the after-effects of sub-expressions.

     Using variables to appraise sub-expressions

     Dim dX, dY

     dY = 6 - 3

     dX = dY

    The folowing table lists all of the bifold algebraic operators. They are bifold because they crave two arguments. The first altercation is on the left-side and the additional altercation is on the right-side. So the abettor + in the announcement 5 + 6 has the bifold arguments 5 and 6.

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

Symbol	Operator	Example
+	Addition	nX + 5
-	Subtraction	nX - 5
	Multiplication	dX
/	Division	dX / -1.5
	Integer Division	dX 6
%	Modulus (remainder)	nX % 6

    The afterward table lists all of the unary algebraic operators. A unary abettor alone has a individual altercation to act on.

    

    

    

    

    

    

    

    

    

    

    

    

Symbol	Operator	Example
-	Negation	-nX

    Of advance you can amalgamate bifold and unary operators in one expression. The after-effects of one bifold operation ability serve as the altercation to your unary operation.

     accumulation the bifold + with the unary -

     dX = -(nX + nY)

    There are some avant-garde algebraic functions that can be acclimated to do circuitous addition which we will allocution about later. These will not be covered in this chapter.

    When alive with strings, Alive Server Pages provides a abundance of functions for manipulating strings. But back we are alone talking about operators that may be acclimated in an expression, we will alone be ambidextrous with the one cord abettor here: the cord chain operator.

    String chain agency that you wish to adjoin one cord to another. This operation is a bifold operation acceptation that it takes two arguments: the left-side is the cord you wish to adjoin to and the right-side is the cord that you wish to append.

     Dim sFirst, sLast, sFullName

     sFirst = Bill

     sLast = Gates

     sFullName = sFirst & & sLast

    As you can see in the archetype above, we are using the cord chain abettor to adjoin three cord ethics together: Bill, , and Gates. Two of the strings are stored in variables while the amplitude appearance is just a cord literal.

    You may concatenate as some variables as you wish calm using the cord chain operator. It has been apparent that cord chain beneath Alive Server Pages is actual inefficient. So if your page is assuming boring and you accept a lot of cord concatenations, you should attending for means to annihilate them.

    Comparision operators, as you ability accept guessed, are acclimated to analyze two altered expressions and acknowledgment a amount of true or false. In alotof cases the two expressions getting comparted will appraise to a number, but it is accessible to analyze cord values, dates and booleans.

    The afterward table lists the bifold allegory operators. These operators crave two announcement arguments: one on the left-side of the abettor and one on the right-side. Just like algebraic expressions, you may amalgamate two-or-more of these expressions together. In the next area we will explain how to these are accumulated using analytic operators.

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

Symbol	Operator	Example
=	Equality	nX = 5
<>	Inequality (Not Equal)	nX <> nY
<	Less Than	nX < 5
>	Greater Than	nX > -5
<=	Less Than or Equal	nX <= 5 + nY
>=	Greater Than or Equal	nX >= dY

    These operators are alotof commony acclimated in an If Then account which will yield an activity based on the boolean aftereffect of an expression. Unless you already accept a boolean amount stored in an ASP variable, you will charge to address an announcement like the following:

     If nX > 60 Then Response.Write You Passed!

     If nX < 60 Then Response.Write You Failed

    Of course, your announcement can be as complicated as you wish as continued as it evaluates to a boolean value.

    Whereas algebraic expressions are acclimated to dispense numbers, analytic operators are acclimated to plan with the two boolean ethics true and false. These operators are consistently acclimated to amalgamate two expressions that aftereffect in boolean values.

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

Symbol	Meaning	Example
And	True alone if both arguments are true, contrarily false	nX > 5 And nX < 10
Or	True if either altercation is true, false alone if both arguments are false	nX < 5 Or nX > 10

    In accession to these bifold operators, there is aswell one unary operator:

    

    

    

    

    

    

    

    

    

    

    

    

    

Symbol	Meaning	Example
Not	Negation, true becomes false and false becomes true	Not (nX > 5)

    The antithesis abettor basically will accord you the adverse amount of the expression. So if the announcement evaluates to true and you accomplish the Not operation on it, it becomes false. Conversely, false will become true if Not is applied.

    So using these analytic operators, we can accumulation some allegory expressions calm to make a actual circuitous announcement like so:

     archetype of a circuitous announcement with four comparisons)

     If (nX = 2) Or (nX < 10 And nX < 20) And Not (nY Response.Write Yes

     End If

    The first allegory (nX = 2) looks just like an assignment. You can never put an appointment in an announcement like this. Appointment alone occurs at the alpha of an expression, area the first attribute is an ASP capricious which is followed by the assignement (=) operator.

    You will apprehension that we acclimated parentheses to accumulation the expressions. Even in some cases area parentheses are not required, it sometimes makes your expressions easier to apprehend if you put them in there.

    For avant-garde programming, Alive Server Pages has operators for alive with alone bits. A bit is the chiffre acclimated in the bifold amount arrangement and was formed from a abbreviating of the words bifold digit. It can alone accept one of two altered values: 0 and 1.

    In the old canicule of computer, programmers were acutely bound in accumulator and had to create the alotof of the accessible storage. One way they did this was by accumulation assorted variables into a individual byte. This has agitated through to modern-day computer systems and this is why we charge bit-wise operators.

    In computer terms, we allocution about bytes. A byte is composed of 8 $.25 and accordingly can accept 2 ^ (raised-to-the-power) 8 or 256 accessible values. An accumulation is composed of two bytes so it can accept a amount of 256 ^ 2 or 65536 accessible values.

    

     The 8 $.25 from a byte and their accumulation equivalents

     +-------------------------------------------------------+

     | Bit7 | Bit6 | Bit5 | Bit4 | Bit3 | Bit2 | Bit1 | Bit0 |

     +------+------+------+------+------+------+------+------+

     |  128 |   64 |   32 |   16 |    8 |    4 |    2 |    1 |

     +-------------------------------------------------------+

    

    For all of the $.25 that are set (equal to 1) above, you charge to add their accumulation agnate to actuate the consistent byte value. So If $.25 6, 4, 1 and 0 were set, the agnate byte amount would be: 64 + 16 + 2 + 1 = 83.

    Going the additional way around, we can catechumen an accumulation to binary. We just yield the accumulation amount and decrease the better bifold amount we can and agenda the agnate bit. We abide to do this adding bifold ethics until we appear up with the consistent bit string:

     catechumen accumulation amount (221) to binary

     221 - 128 = 93 (binary 0x10000000)

     93 - 64 = 29 (binary 0x11000000)

     29 - 16 = 13 (binary 0x11010000)

     13 - 8 = 5 (binary 0x11011000)

     5 - 4 = 1 (binary 0x11011100)

     1 - 1 = 0 (binary 0x11011101)

    When alive with the bit-wise operators, we sometimes accept to catechumen amid bifold and accumulation like this and vice-versa.

    In Alive Server Pages, bit-wise operators are alone acclimated on numeric expressions to dispense alone bits. The numberic announcement can appraise to integers, longs, individual or double-precision numbers. Afterwards evaluating the bit-wise operation, the consistent amount will be accordant with the orignal arguments.

    The afterward bit-wise operators crave two arguments: one on the left-side of the abettor and one on the right-side.

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

Symbol	Meaning	Example
&	Bit-wise And	nX & 5
|	Bit-wise Or	nX | 48
^	Bit-wise Absolute Or	nX ^ 48
<<	Shift $.25 Left	nX << 2
>>	Shift $.25 Right	nX >> 1

    The afterward operators are unary operators acceptation they alone crave one argument. The individual announcement altercation haveto be to the right-side of this operator.

    

    

    

    

    

    

    

    

    

    

    

    

Symbol	Meaning	Example
~	Bit-wise Negation	~ nX

    Truth tables affectation the after-effects of the bifold operators on a bit-by-bit basis. You can anticipate of anniversary bit in the arguments getting evaluated one-by-one. $.25 are akin up based on their position in the bytes. So for a 16-bit integer, anniversary bit would be operated on alone and the consistent $.25 would be strung calm in the aforementioned adjustment to accomplish the consistent number.

    When examination these tables, anticipate to yourself If assuming a bit-wise and (&), bit 0 from altercation 1 and bit 0 from altercation 2 are anded calm and the aftereffect is X. Next bit 1 from altercation 1 and bit 1 from altercation 2 are anded calm and the aftereffect is Y. And continuing on for all the $.25 in the arguments.

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

And (&) Abettor Accuracy Table
Arg #1	Arg #2	Result
0	0	0
0	1	0
1	0	0
1	1	1

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

Or (|) Abettor Accuracy Table
Arg #1	Arg #2	Result
0	0	0
0	1	1
1	0	1
1	1	1

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

Exclusive Or (^) Abettor Accuracy Table
Arg #1	Arg #2	Result
0	0	0
0	1	1
1	0	1
1	1	0

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

Negation (~) Abettor Accuracy Table
Arg #1	Result
1	0
0	1

    ASP has some congenital functions to dispense datetime values. Anticipation technically not operators, we acknowledgment them actuality for abyss back datetime is a accurate data blazon and it is generally all-important to account dates and times.

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

    

Date and Time Functions
Function	Purpose
Date	Get the accepted date according to the bounded machine     dNow = Date()
Time()	Get the accepted time as a datetime amount according to the bounded machine     dTime = Time()
Now()	Get the accepted date AND time according to the bounded machine     dNow = Now()
DateAdd(Interval, Number, Date	Add a specific Amount of Breach to the supplied date     DateAdd(d, 3, Now())
DateDiff(Interval, Date1, Date2)	Calculate the amount of Breach aberration amid Date1 and Date2     dDaysLeft = DateDiff(d, Now(), dBirthDay)
DatePart(Interval, Number, Date)	Retrieve a specific allotment of a date such as the hour or month     DatePart(yyyy, Now())
DateSerial(Year, Month, Day)	Construct a datetime amount from the year, ages and day components     dBirthday = DateSerial(1998, 12, 23)
TimeSerial(Hour, Minute, Second)	Construct a datetime amount absorption the time components.     dNapTime = TimeSerial(14, 0, 0)
DateValue(DateTime)	Convert a date cord into a datetime value.     DateValue(12/23/1998)
TimeValue()	Convert a time cord into a accurate datetime object.     dTime = TimeValue(10:51:43 PM)
Day(Date)	Retrieve the day-of-the-month (0-31) for a specific datetime value     Day(Now())
Month(Date)	Retrieve the ages (1-12) for a specific datetime value     nMonth = Month(dBirthDay)
Year(Date)	Retrieve the year for a specific datetime value.     Year(Now())
Hour(Datetime)	Retrieve the hour (in 24-hour aggressive time architecture [0-23]) for the datetime value     Hour(Now())
Minute(Datetime)	Retrieve the minute (0-59) basic for a specific datetime value     nMinute = Minute(dBirthDay)
Second(Datetime)	Retrieve the abnormal (0-59) for a specific datetime value.     Second(Now())
FormatDateTime(Datetime)	Format the defined datetime amount in a connected format     FormatDateTime(Now(), vbLongDate)

    Information about alternative arguments for these functions and accurate breach types will be discussed in a after chapter. You should agenda that none of the algebraic operators administer to datetime values. You haveto use the assorted about-face and adding functions aloft to dispense dates.

    If you accept a absolutely continued band in ASP that you would like to breach into two lines, you can use the band assiduity operator. This is an accentuate (_) placed at the end of the band that tells the ASP analyst that account or announcement continues on the next line.

    

     if ((bDaysLeft < DateDiff(d, Now(), dBirthDay)) Or _

       (bDaysLeft > DateDiff(d, Now(), dChristMas)) Then

     	Response.Write Hooray!

     End If

    

    In the archetype above, we use the band assiduity to abide a boolean expression. You may use it to abide any blazon of announcement or statement. It makes faculty to breach up continued curve for readability. Just be accurate how you breach curve so that you dont create the band added ambagious to read.

    = Arbitrary =

    There are eight altered types of operators in ASP:

    All but the assignement operators can be acclimated for architecture expressions. Operators are evaluated based on antecedence and the alignment operators. If two operators accept the aforementioned precedence, then the operators are evaluated from left-to-right.

    All date and time ethics haveto be manipulated using functions. The algebraic operators are invalid on datetime values.

    = Analysis Questions =

    = Contest =