The Immediate If Object

**Index**

- Disclaimer
- The Basics
- Conditions

- None - Actions

- None - Expressions

- Result of Last Comparison

-*Return Types...*

->*Integers*

-> -> Compare Integers(n,operator,n,true,false)

-> -> Compare Strings(a,operator,a,true,false)

-> -> Compare Floats(n.n,operator,n.n,true,false)

-> -> Compare Bool(b,true,false)

->*Strings*

-> -> Compare Integers$(n,operator,n,true,false)

-> -> Compare Strings$(a,operator,a,true,false)

-> -> Compare Floats$(n.n,operator,n.n,true,false)

-> -> Compare Bool$(b,true,false)

->*Floats*

-> -> Compare IntegersF(n,operator,n,true,false)

-> -> Compare StringsF(a,operator,a,true,false)

-> -> Compare FloatsF(n.n,operator,n.n,true,false)

-> -> Compare BoolF(b,true,false)

-> Bool

-> -> Compare IntegersB(n,operator,n)

-> -> Compare StringsB(a,operator,a)

-> -> Compare FloatsB(n.n,operator,n.n)

The author of this extension makes no claims concerning the fitness of this extension for any purpose whatsoever, and makes no gurantees, written or implied, of its level of security and safety to authors or to end users in any respect. You agree to use this extension at your own risk and to hold the author harmless in any event.

The Immediate If Object allows you to make decisions inside an expression. It's really quite simple. If the desired comparison results to true, one value is returned. If it results to false, another value is returned. This new version supports Bools. A Bool is either true (1) or false (0), so when you have a return type of bool, you do not need to specify the actual return values because there are only two possibilities.

Supported Operators: =, !=, <>, >, >=, <, <=

**Result of Last Comparison
**

Returns the result of the very last comparison performed by the object.

**Compare Integers(n,operator,n,true,false)**

*CompareIntegers("IIF", Int1, Operator, Int2, Int to
Return on True, Int to Return on False)*

Compares *Int1* and *Int2* using *Operator*
and returns either *Int to Return on True* or *Int to
Return on False* based on the result of the comparison.

**Compare Strings(a,operator,a,true,false)**

*CompareStrings("IIF", String1, Operator, String2,
Int to Return on True, Int to Return on False)*

Compares *String1* and *String2* using *Operator*
and returns either *Int to Return on True* or *Int to
Return on False* based on the result of the comparison.

**Compare Floats(n.n,operator,n.n,true,false)**

*CompareFloats("IIF", Float1, Operator, Float2, Int
to Return on True, Int to Return on False)*

Compares *Float1* and *Float2* using *Operator*
and returns either *Int to Return on True* or *Int to
Return on False* based on the result of the comparison.
Warning: if *Float2* is a float between -1 and 1, it will
produce inaccurate results.

**Compare Bool(b,true,false)**

*CompareBool("IIF", Bool, Int to Return on True, Int
to Return on False)*

Returns either *Int to Return on True* or *Int to
Return on False* based on *Bool*, which is either true
(1) or false (0).

**Compare Integers$(n,operator,n,true,false)**

*CompareIntegers$("IIF", Int1, Operator, Int2,
String to Return on True, String to Return on False)*

Compares *Int1* and *Int2* using *Operator*
and returns either *String to Return on True* or *String
to Return on False* based on the result of the comparison.

**Compare Strings$(a,operator,a,true,false)**

*CompareStrings$("IIF", String1, Operator, String2,
String to Return on True, String to Return on False)*

Compares *String1* and *String2* using *Operator*
and returns either *String to Return on True* or *String
to Return on False* based on the result of the comparison.

**Compare Floats$(n.n,operator,n.n,true,false)**

*CompareFloats$("IIF", Float1, Operator, Float2,
String to Return on True, String to Return on False)*

Compares *Float1* and *Float2* using *Operator*
and returns either *String to Return on True* or *String
to Return on False* based on the result of the comparison.
Warning: if *Float2* is a float between -1 and 1, it will
produce inaccurate results.

**Compare Bool$(b,true,false)**

*CompareBool$("IIF", Bool, String to Return on True,
String to Return on False)*

Returns either *String to Return on True* or *String to
Return on False* based on *Bool*, which is either true
(1) or false (0).

**Compare IntegersF(n,operator,n,true,false)**

*CompareIntegersF("IIF", Int1, Operator, Int2, Float
to Return on True, Float to Return on False)*

Compares *Int1* and *Int2* using *Operator*
and returns either *Float to Return on True* or *Float
to Return on False* based on the result of the comparison.
Warning: if *Float to Return on True* or *Float to
Return on False *are floats between -1 and 1, it will produce
inaccurate results.

**Compare StringsF(a,operator,a,true,false)**

*CompareStringsF("IIF", String1, Operator, String2,
Float to Return on True, Float to Return on False)*

Compares *String1* and *String2* using *Operator*
and returns either *Float to Return on True* or *Float
to Return on False* based on the result of the comparison.
Warning: if *Float to Return on True* or *Float to
Return on False *are floats between -1 and 1, it will produce
inaccurate results.

**Compare FloatsF(n.n,operator,n.n,true,false)**

*CompareFloatsF("IIF", Float1, Operator, Float2,
Float to Return on True, Float to Return on False)*

Compares *Float1* and *Float2* using *Operator*
and returns either *Float to Return on True* or *Float
to Return on False* based on the result of the comparison.
Warning: if *Float2*, *Float to Return on True*, or
*Float to Return on False *are floats between -1 and 1, it
will produce inaccurate results.

**Compare BoolF(b,true,false)**

*CompareBoolF("IIF", Bool, Float to Return on True,
Float to Return on False)*

Returns either *Float to Return on True* or *Float to
Return on False* based on *Bool*, which is either true
(1) or false (0). Warning: if *Float to Return on True* or
*Float to Return on False *are floats between -1 and 1, it
will produce inaccurate results.

**Compare IntegersB(n,operator,n)**

*CompareIntegersB("IIF", Int1, Operator, Int2)*

Compares *Int1* and *Int2* using *Operator*
and returns the result of the comparison, either 1 (true) or 0
(false).

**Compare StringsB(a,operator,a)**

*CompareStringsB("IIF", String1, Operator, String2)*

Compares *String1* and *String2* using *Operator*
and returns the result of the comparison, either 1 (true) or 0
(false).

**Compare FloatsB(n.n,operator,n.n)**

*CompareFloatsB("IIF", Float1, Operator, Float2,)*

Compares *Float1* and *Float2* using *Operator*
and returns the result of the comparison, either 1 (true) or 0
(false). Warning: if *Float2* is a float between -1 and 1,
it will produce inaccurate results.