---
title: "Assignment operators"
canonical: "https://docs.cuesystem.com/space/CVCHELP/522682838/Assignment%20operators"
format: markdown
---
> Macro (toc)

---

# :=

The operator assignment is used to assign a value to a variable. Multiple assignments are not possible. 

Do not confuse operator "=" and operator ":=". 

#### Syntax 

```visualbasic
Result := Expression
```

#### Example 

```visualbasic
Var a As Long := 8 
Var c As Long 

c := a 
// c := 8
```

# +=

The operator compound assignment plus is equivalent to: 

Result := Result + Expression 

#### Syntax 

```visualbasic
Result += Expression
```

#### Example 

```visualbasic
Var i As Long := 100 
Var j As Long := 0 

i += 1 
j += 2 * i + 5
```

#### It is equivalent to the example 

```visualbasic
Var i As Long := 100 
Var j As Long := 0 

i := i + 1 
j := j + (2 * i + 5)
```

# -=

The operator compound assignment minus is equivalent to: 

Result := Result - Expression 

#### Syntax 

```visualbasic
Result -= Expression
```

#### Example* *

```visualbasic
Var i As Long := 100 
Var j As Long := 0 

i -= 1 
j -= 2 * i + 5
```

#### It is equivalent to the example 

```visualbasic
Var i As Long := 100 
Var j As Long := 0 

i := i - 1 
j := j – (2 * i + 5)
```

# *=

The operator compound assignment multiplying is equivalent to: 

Result := Result * Expression 

#### Syntax 

```visualbasic
Result *= Expression
```

#### Example 

```visualbasic
Var i As Long := 100 
Var j As Long := 0 

i *= 1 
j *= 2 * i + 5
```

#### It is equivalent to the example 

```visualbasic
Var i As Long := 100 
Var j As Long := 0 

i := i * 1 
j := j * (2 * i + 5)
```

# /=

The operator compound assignment dividing is equivalent to: 

Result := Result / Expression 

#### Syntax 

```visualbasic
Result /= Expression
```

#### Example 

```visualbasic
Var i As Long := 100 
Var j As Long := 0 

i /= 1 
j /= 2 * i + 5
```

#### It is equivalent to the example 

```visualbasic
Var i As Long := 100 
Var j As Long := 0 

i := i / 1 
j := j / (2 * i + 5)
```

# Mod=

The operator compound assignment remainder is equivalent to: 

Result := Result **Mod** Expression 

#### Syntax 

```visualbasic
Result Mod= Expression
```

#### Example 

```visualbasic
Var i As Long := 100 
Var j As Long := 0 

i Mod= 1 
j Mod= 2 * i + 5
```

#### It is equivalent to the example 

```visualbasic
Var i As Long := 100 
Var j As Long := 0 

i := i Mod 1 
j := j Mod (2 * i + 5)
```

# ^=

The operator compound assignment power is equivalent to: 

Result := Result ^ Expression 

#### Syntax* *

```visualbasic
Result ^= Expression
```

#### Example 

```visualbasic
Var i As Long := 2 
Var j As Long := 2 

i ^= 3 
j ^= 2 * 3 + 10
```

#### It is equivalent to the example 

```visualbasic
Var i As Long := 2 
Var j As Long := 2 

i := i ^ 3 
j := j ^ (2 * 3 + 10)
```

# <<=

The operator compound assignment bitwise shift left is equivalent to: 

Result := Result << Expression 

#### Syntax 

```visualbasic
Result <<= Expression
```

#### Example 

```visualbasic
Var i As Long := &H20 
Var j As Long := &H20 

i <<= 3 
j <<= 2 * 3 + 1
```

#### It is equivalent to the example 

```visualbasic
Var i As Long := &H20 
Var j As Long := &H20 

i := i << 3 
j := j << (2 * 3 + 1)
```

# >>=

The operator compound assignment bitwise shift right is equivalent to: 

Result := Result >> Expression 

#### Syntax 

```visualbasic
Result >>= Expression
```

#### Example 

```visualbasic
Var i As Long := &H20000 
Var j As Long := &H20000 

i >>= 3 
j >>= 2 * 3 + 1
```

#### It is equivalent to the example 

```visualbasic
Var i As Long := &H20000 
Var j As Long := &H20000 

i := i >> 3 
j := j >> (2 * 3 + 1)
```

# And=

The operator compound assignment is logical and is equivalent to: 

Result := Result **And** Expression 

#### Syntax 

```visualbasic
Result And= Expression
```

#### Example 

```visualbasic
Var a As Boolean 
Var b As Boolean 
Var c As Boolean 

c And= a 
c And= a Or b
```

#### It is equivalent to the example 

```visualbasic
Var a As Boolean 
Var b As Boolean 
Var c As Boolean 

c := c And a 
c := c And (a Or b)
```

# Or=

The operator compound assignment is logical or is equivalent to: 

Result := Result **Or** Expression 

#### Syntax 

```visualbasic
Result Or= Expression
```

#### Example 

```visualbasic
Var a As Boolean 
Var b As Boolean 
Var c As Boolean 

c Or= a 
c Or= a And b
```

#### It is equivalent to the example 

```visualbasic
Var a As Boolean 
Var b As Boolean 
Var c As Boolean 

c := c Or a 
c := c Or (a And b)
```

# Xor=

The operator compound assignment logical xor is equivalent to: 

Result := Result **Xor** Expression 

#### Syntax 

```visualbasic
Result Xor= Expression
```

#### **Example** 

```visualbasic
Var a As Boolean 
Var b As Boolean 
Var c As Boolean 

c Xor= a 
c Xor= a And b
```

#### It is equivalent to the example 

```visualbasic
Var a As Boolean 
Var b As Boolean 
Var c As Boolean 

c := c Xor a 
c := c Xor (a And b)
```

# BitAnd=

The operator compound assignment bitwise and is equivalent to: 

Result := Result **BitAnd** Expression 

#### Syntax 

```visualbasic
Result BitAnd= Expression
```

#### Example 

```visualbasic
Var a As Byte 
Var b As Byte 
Var c As Byte 

c BitAnd= a 
c BitAnd= a BitOr b
```

#### It is equivalent to the example 

```visualbasic
Var a As Byte 
Var b As Byte 
Var c As Byte 

c := c BitAnd a 
c := c BitAnd (a BitOr b)
```

# BitOr=

The operator compound assignment bitwise or is equivalent to: 

Result := Result **BitOr** Expression 

#### Syntax 

```visualbasic
Result BitOr= Expression
```

#### Example 

```visualbasic
Var a As Byte 
Var b As Byte 
Var c As Byte 

c BitOr= a 
c BitOr= a BitAnd b
```

#### It is equivalent to the example 

```visualbasic
Var a As Byte 
Var b As Byte 
Var c As Byte 

c := c BitOr a 
c := c BitOr (a BitAnd b)
```

# BitXor=

The operator compound assignment bitwise xor is equivalent to: 

Result := Result **BitXor** Expression 

#### Syntax 

```visualbasic
Result BitXor= Expression
```

#### Example 

```visualbasic
Var a As Byte 
Var b As Byte 
Var c As Byte 

c BitXor= a 
c BitXor= a BitAnd b
```

#### It is equivalent to the example* *

```visualbasic
Var a As Byte 
Var b As Byte 
Var c As Byte 

c := c BitXor a 
c := c BitXor (a BitAnd b)
```