Boolean values: Difference between revisions

==={{header|Applesoft BASIC}}===

IF statement condition treats any non-zero numeric value as true. Comparison operators evaluate to 1 (true) or 0 (false).

Examples:<lang ApplesoftBASIC>? 2 = 3

? 2 = 2

IF 7 THEN ?"HELLO"</lang>

{{out}}

<pre>0

1

HELLO</pre>

==={{header|BASIC256}}===

==={{header|BBC BASIC}}===

<lang bbcbasic> REM BBC BASIC uses integers to represent Booleans; the keywords

REM FALSE and TRUE equate to 0 and -1 (&FFFFFFFF) respectively:

PRINT FALSE

PRINT TRUE</lang>

==={{header|Commodore BASIC}}===

Commodore BASIC evaluates any non-zero number for TRUE&mdash;but is typically represented as 16-bit signed integer value of -1 or $FFFF&mdash;and zero evaluates to FALSE.

<lang gwbasic>10 f%=("z"="a") : t%=not f% : rem capture a boolean evaluation

15 print chr$(147);chr$(14);

20 print "True is evaulated as:";t%

30 print "False is evaluated as:";f%

40 print:print "Any non-zero number will evaluate to"

50 print "true as shown in this example:":print

60 for i=-2 to 2

70 print i;" = ";

80 if i then print "True":goto 100

90 print "False"

100 next</lang>

{{out}}

<pre>

True is evaulated as:-1

False is evaluated as: 0

Any non-zero number will evaluate to

true as shown in this example:

-2 = True

-1 = True

0 = False

1 = True

2 = True

ready.

&#9608;

</pre>

==={{header|FreeBASIC}}===

FreeBASIC has a built-in Boolean type (equivalent to a signed one byte integer) with built-in constants true and false to represent values of that type. Note also that:

* Numeric expresions can be converted to the Boolean type either implicitly or using the CBool operator - zero is converted to false and non-zero to true.

* Boolean expressions can be converted to a numeric type either implicitly or using the appropriate cast operator (CInt, CByte, CDbl etc) - false is converted to 0 and true to -1.

* String expressions such as "false" and "true" (regardless of case) can also be converted to Boolean using CBool.

* It is possible to overload CBool for user-defined types to yield a Boolean value.

Sample code:

<lang freebasic>' FB 1.05.0 Win64

Dim i As Integer = 23

Dim s As String = "False"

Dim b As Boolean

b = i

Print b

b = CBool(s)

Print b

i = b

Print i

i = CInt(true)

Print i

Sleep</lang>

{{out}}

<pre>

true

false

0

-1

</pre>

==={{header|Liberty BASIC}}===

IF-statement, loop condition treats any non-zero integer as true.

Comparison operators evaluate to 1 (true) or 0 (false).

==={{header|Microsoft Small Basic}}===

Microsoft Small Basic has two constants: <code>"True"</code> and <code>"False"</code>.<br>

<lang smallbasic>If c Then

notc = "False"

Else

notc = "True"

EndIf</lang>

==={{header|PowerBASIC}}===

In addition to what's noted above under [[#BASIC|BASIC]], [[PowerBASIC for Windows]] and [[PowerBASIC Console Compiler]] have the <code>ISTRUE</code> and <code>ISFALSE</code> functions. According to the help file, they "return the logical truth or falsity of a given expression". ([[PowerBASIC]] lacks a boolean data type, so the usual practice is to use integers in [[PB/DOS]], and longs in [[PB/CC]] and [[PB/Win]].)

<lang powerbasic>DIM x AS LONG

x = ISTRUE(1 = 1) ' returns -1

x = ISTRUE(1 = 0) ' returns 0

x = ISFALSE(1 = 1) ' returns 0

x = ISFALSE(1 = 0) ' returns -1</lang>

==={{header|PureBasic}}===

PureBasic does not have a Boolean variable type. An integer type is typically used instead. Boolean values are only supported as part of a loop's condition (While/Wend, Repeat/Until) or in a conditional (If/Endif). In these cases if the result of a variable or a numeric expression is zero it is evaluated as False, otherwise it is evaluated as True. A string variable assigned a null string would be evaluated as False.

==={{header|QBasic}}===

QBasic, QuickBASIC, VB-DOS and GW-BASIC doesn't have a Boolean type. What it does is to take 0 as False, and any other value as True. The easiest way in QBASIC, QuickBASIC and VB-DOS is to create False and True constants of type Integer and, then, use them as needed:

<lang QBASIC>

CONST FALSE=0

CONST TRUE = Not FALSE

Print FALSE

Print TRUE

</Lang>

In GW-BASIC you can create a variable called FALSE% and other called TRUE% and do the same. Nevertheless, is more sure to create functions in order to avoid the value to be manipulated:

<lang QBASIC>

10 DEF FNFALSE = 0

20 DEF FNTRUE = NOT FNFALSE

30 Print FNFALSE

40 Print NFTRUE

</Lang>

==={{header|Run BASIC}}===

Basically 0 is false and 1 is true

<lang runbasic>if 1 then print "1 is true"

if not(0) then print "0 is false"

if 1 < 2 then print "1 < 2 TRUE"

if 2 > 1 then print "2 > 1 TRUE"

if not(2 < 1) then print "2 not < 1"

if not(1 = 0) then print "1 not = 0"</lang>

==={{header|smart BASIC}}===

<ul>

<li>IF/THEN statements treat any non-zero value as true and zero as false.</li>

<li>Comparison operators DO NOT calculate in smart BASIC. For example, PRINT (1 > 4) WILL NOT evaluate to produce a zero value (0) indicating a false condition. It will produce an error. All Boolean evaluations in smart BASIC must be determined within IF/THEN statements. </li>

</ul>

==={{header|TI-89 BASIC}}===

There are boolean literals <code>true</code> and <code>false</code>. No other values may be used where a boolean is expected.

==={{header|uBasic/4tH}}===

In conditionals, zero is false, non-zero is true. Note that '''=''' is not only used for assignment, it is also a fully qualified logical operator, so it is easy to assign a true boolean to a variable.

<lang>t = 1 = 1

f = 0 = 1

Print "False = ";f;", True = ";t</lang>

{{out}}

<pre>False = 0, True = 1

0 OK, 0:52</pre>

==={{header|Visual Basic}}===

VB has the <code>Boolean</code> data type and the constants <code>True</code> and <code>False</code>, in addition to what's listed under [[#BASIC|BASIC]], above. When used outside of a boolean context, <code>True</code> and <code>False</code> return values depending on their context -- <code>-1</code> and <code>0</code> in a numeric context, <code>"True"</code> and <code>"False"</code> if used as strings.

<br>When converting an integer to a boolean, <code>0</code> is <code>False</code> and anything not equal to <code>0</code> is

<lang vb>Dim x As Boolean

x = IIf(Int(Rnd * 2), True, False)

MsgBox x</lang>