for each item as ArrayType in myArray
  if item.Matches( myValue ) then
    YesSiree( myValue )
    exit
  end if
next

That’s pretty easy, but what if the array is really big? And what if you have to do this many times?

For example, let’s say your array has 10,000 items. For each value that doesn’t match, your code will have to do 10,000 comparisons. But, if your array can be sorted, you can perform that task with, at most, 14 comparisons using a binary search.

The concept is simple: you take an ordered list and start in the middle. If what you’re trying to match is less than that point, you discard the upper half of the list, then start again at the midpoint of the rest. By continuously cutting the list in half, you will do, at most, Ceil(Log2(arrayCount)) comparisons per value.

For simplicity’s sake, let’s say you want to search an array of strings. (Yes, a Dictionary would be the better choice here, but this is just for illustration.) The code would look something like this:

myArray.Sort

var firstIndex as integer = 0
var lastIndex as integer = myArray.LastIndex

while firstIndex <= lastIndex
  var midPoint as integer = ( lastIndex - firstIndex ) \ 2 + firstIndex

  var compare as string = myArray( midPoint )

  if myValue = compare then
    YesSiree( myValue )
    exit
  end if

  if myValue < compare then
    lastIndex = midPoint - 1
  else
    firstIndex = midPoint + 1
  end if
wend

With that 10,000-item array, the first loop would look at item 5,000. If myValue is greater than that, it would next look at item 7,500. Still greater? Now it will look at item 8,750, and so on. The entire array will be processed efficiently with large chunks never needing examination at all. If you have to do this for 1,000 different values, you will end with, at most, 14,000 comparisons instead of 10 million.

Quite the savings, right?

Kem Tekinay is a Mac consultant and programmer who has been using Xojo since its first release to create custom solutions for clients. He is the author of the popular utilities TFTP Client and RegExRX (both written with Xojo) and lives in Connecticut with his wife Lisa, and their cat.

• Facebook
• X
• LinkedIn
• GitHub
• YouTube

Xojo Linux is Free

We have made building for Linux free and included in the Xojo IDE! This means that on Linux you get a version control ready IDE, along with the ability to build desktop and console Linux apps (including Raspberry Pi), all for free. Launch Xojo 2024r1 (or any later release of Xojo) and open any desktop or console project, go to Build Settings, select Linux and in the Inspector choose the appropriate Architecture that matches the Linux OS you want your app to work on, either ARM or x86. Click Build to compile your project to a standalone app that you can then run on Linux – no license required.

Wrapping Up

All these changes were made based on feedback from the Xojo community and to better match the changing ways that people develop and share software projects. With this change Xojo continues its dedication to supporting Linux.

Download Xojo to get started.

Edited 07/2025 to reflect changes to licensing.

I’d like to show you how to create an Enum for Days of the Week and demonstrate the use of that by creating a custom segmented button control.

Open Xojo and create a new Desktop Project.  Insert a module and give it a name – I called mine Enumerations.

Next, add an enumeration.

Call this Enum DaysOfWeek and make it a binary enum.

Next, fill in the Declarations.

Next, I’m going to add a bunch of Constants to the module, one for each day of the week.  This will allow me to localise the control later.

Now I’ll add a convenience method called ToString that will extend the DaysOfWeek Enum.

The code in this method is:

Var SelectedDays() As String

Var d As DaysOfWeek

d = DaysOfWeek.Sunday
If Value.Contains(d) Then
  SelectedDays.Add(Day1)
End If

d = DaysOfWeek.Monday
If Value.Contains(d) Then
  SelectedDays.Add(Day2)
End If

d = DaysOfWeek.Tuesday
If Value.Contains(d) Then
  SelectedDays.Add(Day3)
End If

d = DaysOfWeek.Wednesday
If Value.Contains(d) Then
  SelectedDays.Add(Day4)
End If

d = DaysOfWeek.Thursday
If Value.Contains(d) Then
  SelectedDays.Add(Day5)
End If

d = DaysOfWeek.Friday
If Value.Contains(d) Then
  SelectedDays.Add(Day6)
End If

d = DaysOfWeek.Saturday
If Value.Contains(d) Then
  SelectedDays.Add(Day7)
End If

Return String.FromArray(SelectedDays, ", ")

You can see from this code that it is possible to include multiple days in this Enum.  The return string might be “Sunday, Monday, Friday” for example.

Create the DaysOfWeek Control by dragging a segmented button from the library to the navigator and naming it DaysOfWeekControl.

Then use the Inspector Behaviour option to customise the control.

Change the default width to 500 and the selection style to 1 for multiple

Unfortunately, we can’t edit the segments here as the control is a textfield, not a textarea and the edit button is missing.  But we can edit the source file (you need a license capable of saving the project in text format).  Save and close the project, and open the DaysOfWeekControl.xojo_code file in Notepad, search for “One” which will find the initial value of the control.

You can see each segment is separated with “\r” which the IDE translates to <CR>.  Replace “One\rTwo” with “#Day1\r#Day2\r#Day3\r#Day4\r#Day5\r#Day6\r#Day7” which will tell the compiler to use the localised Day constants created earlier. Save the code file and reopen the project.

Now we can continue customising the control first adding a computed property Value As DaysOfWeek. In the Get method add this code:

Var Result As DaysOfWeek = 0 ' The default value is set to create an instance of Result
For i As Integer = 0 To 6 ' Each Segment in the control
  If me.SegmentAt(i).Selected Then
    Var d As DaysOfWeek = 2 ^ i ' Converts the index (i) to the binary number that matches the value of the enum
    Result = Result Or d ' Adds the selected day to the enum
  End If
Next i

Return Result

You’ll notice the first line sets the value of Result to 0, this is important as otherwise the variable will be Nil – remember this is being rendered as a class by the compiler.

In the Set Method place this code:

For i As Integer = 0 To 6 ' Index of each segment
  Var d As DaysOfWeek = 2 ^ i ' Convert the index (i) to binary
  me.SegmentAt(i).Selected = value.Contains(d) ' Set the selected state of the button
Next i

RaiseEvent ValueChanged(value)

This will show the button as pressed or not depending on whether the day is included on the value.  Now add an event definition.

Which will raise when a button is pressed, which means we need to handle the pressed event of the control.

Sub Pressed(segmentIndex as integer) Handles Pressed
  #Pragma Unused segmentIndex

  RaiseEvent ValueChanged(Value)
 End Sub

Time to use the control. We want to place a copy of the control onto Window1; we can either drag the control from the Navigator or select it from the Library (it will show in the Project Controls section). I’m also going to add a label to the Window under the DaysofWeek control, name it SelectedDaysLabel and make it the same width as the control (500). This will be where we will show the result of the days selected.

Next, handle the ValueChanged event on the control:

Sub ValueChanged(Value As DaysOfWeek) Handles ValueChanged
  SelectedDaysLabel.Text = Value.ToString
End Sub

When we run the project and select some days, we’ll see something similar to the following.

Now to show the power of the binary enum I’m going to add another declaration to the Enumeration “WeekDays” with a value of 62

62 is the total of the values for Monday through Friday. Once we have this, we can add a button to the window and set its “Pressed” event handler to:

Sub Pressed() Handles Pressed
  DaysOfWeekControl1.Value = DaysOfWeek.Weekdays
End Sub

Pressing the button will result in:

Taking this further we can add the enum value to the DateTime class by adding another Extension method to the module as below.

Public Function DayOfWeekEnum(Extends Value As DateTime) As DaysOfWeek  

  Var Result As DaysOfWeek = 2 ^ (Value.DayOfWeek - 1)
  Return Result

End Function

We need to subtract 1 from the DayOfWeek property of the passed DateTime object as the days are 1 based not 0 as in the control. To demonstrate how this works I’m going to add a multiline label to the window called SelectedDatesLabel and set that to show which dates over the next week have been selected by updating the ValueChanged handler as below:

Sub ValueChanged(Value As DaysOfWeek) Handles ValueChanged

SelectedDaysLabel.Text = Value.ToString

SelectedDatesLabel.Text = ""

For i As Integer = 1 To 7 ' From tomorrow for a week
 Var dt As DateTime = DateTime.Now.AddInterval(0, 0, i)
 If Value.Contains(dt.DayOfWeekEnum) Then
  SelectedDatesLabel.Text = SelectedDatesLabel.Text + _
  dt.ToString(DateTime.FormatStyles.Short, DateTime.FormatStyles.None) _
  + EndOfLine
    End If
  Next i

End Sub

That’s it folks, hope you enjoyed this tutorial.

Wayne Golding has been a Xojo developer since 2005 and is a Xojo MVP. He operates the IT Company Axis Direct Ltd which primarily develops applications using Xojo that integrate with Xero www.xero.com. Wayne’s hobby is robotics where he uses Xojo to build applications for his Raspberry Pi, often implementing IoT for remote control.

In addition, we’ve added a new Binary option which allows you to automatically create sets that aren’t mutually exclusive. That is, the values of the elements are automatically powers of two and can have binary operations applied to them:

This new feature comes with the requirement that they be placed inside a Module because they’re rendered into your project as a Class. The reason for this is that these classes automatically have some helper methods on them to make working with the binary data easier.

• An Operator_Convert which takes an Integer:
  Var x as MyEnum = 3 // MyEnum.George, MyEnum.John
  
• …as well as one that returns an integer:
  Var y as Integer = MyEnum.George // y = 2
  
• Automatic conversion to and from Integer:
  Var x as Integer = MyEnum.Ringo // x = 4
  
• Binary operations And, Or and Xor:
  Var x as MyEnum = MyEnum.Paul Or MyEnum.Mary // x has a value of 40
  
• Equality operations so you can compare the internal value of one instance to another:
  Var x as MyEnum = MyEnum.Paul
Var y as MyEnum = MyEnum.Ringo
If x = y Then
  
• Contains helper method:
  If x.Contains(MyEnum.Peter) Then
  
• A Read-Only Value property so you can see the internal value in the debugger

Just like regular Enumerations, the editor also allows you to explicitly specify the value of an element:

This is so instead of having to write:
Var x as MyEnum = MyEnum.George Or MyEnum.John Or MyEnum.Ringo Or MyEnum.Paul

You can simply write:
Var x as MyEnum = MyEnum.TheBeatles

We hope that you’ll enjoy this feature as much as we do!

So if we start counting up values are written as:

1 => &b00000001
2 => &b00000010
3 => &b00000011

and so on until we get to:

127 => &b01111111

Now, what’s the “next number”? That would be:

&b10000000

which this code:

Dim i As Int8 = &b10000000

tells you is -128.

What does -128 look like in something like an Int16?

Dim i8 As Int8 = &b10000000
Dim i16 As Int16 = i8

System.DebugLog(Bin(i8)) // <<< shows 10000000
System.DebugLog(Bin(i16)) // <<< shows 1111111110000000

Why is the int16 have all those 1’s at the beginning? It’s because if you assign:

Dim i16 As Int16 = &b1000000000000000

you’ll find that this is -32768 or the smallest value an Int16 can hold. When you assign a little value like -128 the “lowest” 8-bit can be copied from the int8 form and the upper 8 bits have to be copies of the “sign bit” – that first one after the “&b”.

This is called sign extension and is required when you move a smaller type into a larger one — like moving an Int8 into an Int16 or an Int8 into an Int32.

Failing to do this for signed values (i.e. if the code did something like “fill the upper part with 0s”):

Dim i8 As Int8 = &b10000000
System.DebugLog(Bin(i8))

Dim i16 As Int16 = &b0000000010000000
System.DebugLog(Bin(i16))

would have the Int8 value saying it held -128 and the Int16 saying it held 128 (note the sign change!) and this would totally wreck trying to do any math.

Remember this is all necessary in order to manage the sign of an integer. It is not necessary with unsigned types such as UInt8, UInt16, etc.

Binary is the type of numbering system that is native to computers. It is base-2. Numbers that normal people work with are called decimal or base-10.

For normal base-10 numbers you use the digits 0 through 9 to describe a number. Here’s how you would count out 10 things:

1
2
3
4
5
6
7
8
9

And now you’ve run out out digits. So you put a “1” in the tens place and a “0” in the ones place to get:

10

To try counting the same quantity in binary your first realization should be that you only have two digits (base-2) to work with: 0 and 1. So the counting would look like this:

1

And now you’ve immediately run out of digits. So you put a “1” in the twos place and a “0” in the ones place and start counting again:

10
11

And you’ve run out of digits again. This happens a lot with binary, which is why it’s not a great numbering system for people. Just continue the pattern to keep counting:

100
101
110
111

1000
1001
1010

We’ll stop here since we have now counted up to “10” in decimal.

Another way you can parse this number is to think of how each position represents a component of the number.

With binary 1010 the components are as follows:

1 * 23 = 8
0 * 22 = 0
1 * 21 = 2
0 * 20 = 0

Adding 8 + 2 gets you to 10 decimal.

You’ve probably heard the term “8-bit” so what is an 8-bit number? Because bits are either 0 or 1 they are represented as binary. So an 8-bit binary number with all values set to one is this:

11111111

That is the largest number you can fit into 8 bits. And converted to decimal it is:

1 * 2^7 + 1 * 2^6 + 1 * 2^5 + 1 * 2^4 + 1 * 2^3 + 1 * 2^2 + 1 * 2^1 + 1 * 2^0

That breaks down to:

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

Which sums to 255, a number I’m sure you’ve seen around before. It is the maximum value you get with the UInt8 data type in Xojo.

Conversely, you can convert a decimal number to binary by repeatedly dividing it by 2 and noting the remainder. When the remainder is even you write a 0, when it is odd you write a 1. And then you read the number from the bottom up.

So to convert decimal 10 to binary:

10 / 2 = 5, with a remainder of 0. 0 is even so write a “0”:

0

Now divide 5 / 2 to get 2 with a remainder of 1, which is odd:

0
1

Now divide 2 /2 to get 1, with a remainder of 0:

0
1
0

Lastly, divide 1 / 2 to get 0 with a remainder of 1 which is odd. So you end up with this:

0
1
0
1

Reading that from the bottom up gives you: 1010

I hope you now consider yourself part of the group that understands binary!