Difference between revisions of "mirc/variables"

Latest revision as of 05:09, 5 June 2022

mIRC variables are items which can hold data temporarily, or permanently, for use at a later time.. You can create, edit, or delete them at any time. All mIRC variables must be prefixed with a % sigil (example %var or %cookies). Variables are untyped – therefore capable of storing letters, numbers, or strings at any given point.

1 Variable Scope: Global vs. Local
- 1.1 Local Variables
- 1.2 Global Variables
2 Semi global
3 The equal sign '='
4 Unsetting Variables
- 4.1 Syntax:
5 $null values
6 Math Operations
7 Others Commands
8 Dynamic Variable Names
- 8.1 Setting Values
- 8.2 Retrieving Values
9 Special behaviors & quirks
10 Conclusion

Variable Scope: Global vs. Local[edit]

There are two kinds of variables: local and global. Scope refers to the visibility of variables in your code. In other word, where these variables can be seen from.

Local Variables[edit]

Local Variables are given local scope. They are created for the duration of the routine that created them and they can only be accessed from within that routine Once the routine is finished, the variable is deleted. A routine represents an alias, an event, a menu, or when you execute code with two /slash from the editbox.

Note: Local variables can be seen from the execution of /scon or /scid: //var %a ok | scon -r echo -a $ + %a ($1- can't be seen the same way)

Syntax:

;single variable
var %temp = value
 
;multiple variables
var %a = value, %b = second value, %c = and so on and so forth

Note: Since mIRC 6.21, you can avoid using the = sign when using the /var command.

Local variables are good for temporary things like string manipulations and math expressions. Most of your code will use local variables.

Below is a simple addition alias that uses two local variables:

alias add {
  var %number1 = $1, %number2 = $2
  echo -a %number1 + %number2 = $calc(%number1 + %number2)
}

An example usage of the script above is: /add 1 3 which will output: 1 + 3 = 4. Once the add alias has finished executing, both "%number1" and "%number2" are destroyed. Remember, these local variables cannot be called upon outside of their code blocks.

Incorrect use of local variables:

alias wrong {
  var %myvar = 3
  wronger
}
alias wronger {
  echo -a %myvar
}

If you were to execute the above by typing /wrong, you would get the following error: * /echo: insufficient parameters. This is because the local variable, in this case %myvar, has been stored within the wrong alias code block, and is, therefore, unavailable to the /wronger alias that has been called.

Global Variables[edit]

A global variable is a variable that is accessible from every alias or event. They can be created and edited from every script. They are not deleted unless they are purposely destroyed using the unset command (we will talk about that later on).

Syntax:

;create variable
set %var value

Note: The /set command does not use the = operator.

Because the /set command can only set a single variable at a time, you can use the /var command in conjunction with -g switch to set multiple global variables.

;multiple variables
var -g %var = foo, %var2 = bar, %var3 = foobar

Practical use: a global variable is good for storing variables that you will need to use in the future from another script or at different time. (Login System, Away System, Sockets, Etc...)

Semi global[edit]

You can use set -u0 to create a variable that can be seen by any routine (global) but is destroyed when the scripting engine exits (when all routines are done), like binary variables.

The equal sign '='[edit]

Although it's not required in /var since 6.21, the equal sign can be used to assign a value to a variable without actually using a command:

%var = value

If %var is local, this will change the local variable. If %var is global, it will naturally change the global variable. If %var doesn't exist, it will create a global variable.

Unsetting Variables[edit]

If you have already set a variable you can unset it at any time during using the /unset command. The unset command supports a single variable or multiple variables. Generally, there is no reason to unset local variables as they will get destroyed anyway at the conclusion of the script execution.

Syntax:[edit]

;unset a single variable
unset %variable
 
;unset multiple variables
unset %var1 %var2 %var3

The /unset command supports wildcard characters for each of the variable, to be able to unset multiple variables. For example:

alias unsetWildExample {
  set %exampleHello hello there
  set %exampleHey another var
  set %exampleVar yet another var
 
  /*
   Illustrating that each variable can be a wildcard
   unset -s %exampleH* %exampleVar
 
  */ 
 
  ;unset all of them
  unset %example*
}

You can also unset all of the variables using the /unsetall command.

Caution: This will permanently delete all of your variables! You cannot recover them once you have performed this command, so be careful.

$null values[edit]

If a variable is referred to but does not exist, it returns the value $null. Likewise, a variable without any data stored in it returns $null as well.

alias nullExample {
  ; make sure our variable doesn't exist
  unset %example1
  if (%example1 == $null) {
    echo -a % $+ example1 is null!
  }
  ; set a variable with no data
  set %example2
  if (%example2 == $null) {
    echo -a % $+ example2 is also null!
  }
}

Upon executing /nullExample, you will notice that mIRC will echo the following to the active window:

%example1 is null!
%example2 is also null!

Math Operations[edit]

You can do one math operation with variable when setting a value.

The operators supported are: '+' '-' '/' '*' '%' '^' where % is the modulus and ^ is power.

You must use a space around all 3 parameters and you must provide correct values, numbers can be float.

If you don't respect the format, it will set the value as plain text, use -n or -p to override this behavior when dynamic content.

It also supports '&' as the logical-AND operator, but it's supported differently than how $and() handles inputs. Here, the output is valid only if the inputs are valid within the signed 32-bit range. If 1 input is valid and the other is >= 2^31, the result is zero. If 1 input is valid and the other is < -2^31, the result is always -2^31. Unlike how $and casts negative results into an integer in the range 2^31 <= n < 2^32, var can output negative numbers.

For Example:

alias mathExample {
  ;10
  var %a = 5 + 5
  ;9
  var %b = %a - 1
  ;90
  var %c = %b * %a
  ;print it to the screen
  echo -a %c
}

Others Commands[edit]

mIRC has two additional commands that can be used to easily increase and decrease the value of a numerical variable.

The dec command allows you to decrease the value of a variable by 1 or by a given value if specified:

dec %var [value]

For Example:

alias example {
  var %g = 10
  dec %g
  ;9
  echo -a %g
}

The inc command allows you to increase the value of a variable by 1 or by a given value if specified:

inc %var [value]

For Example:

on *:action:$(slaps $me $+ *):#mSL:{
  ;increase the variable by 1
  inc %slaps
  msg $chan I have seen %slaps slaps!
}

Dynamic Variable Names[edit]

In many occasions you may need to save individualized data (data for a particular user or channel for example). Dynamic variables allow you to do just that. A dynamic variable's name usually consists of a static part (a part that doesn't change) and a dynamic part (the part that changes).

Setting Values[edit]

The basic syntax to set a dynamic variable is:

set %<static_part> $+ <dynamic_part>
; or (use var -g to make them global variables)
var %<static_part> $+ <dynamic_part>

Although you can omit the static part out, its strongly discouraged because variables should have a meaningful name that explains their purpose.

Note: You may have seen script using evaluation brackets to set a value to a dynamic variable, they are not required.

Let's take a look at an example:

on *:text:!setColor *:#:{
  ;save their favorite color
  set %color. $+ $nick $2
  notice $nick Your favorite color $qt($2) was saved!
}

Let's take a closer look at the variable assignment statement:

set %color. $+ $nick $2

The static part is color., which is never going to change, and the dynamic part is $nick. Let's assume someone by the name John types !setColor blue; this is what happens:

mIRC evaluates the identifier $nick to "John" and $2 to blue
```
set %color. $+ John blue
```
mIRC will then append "John" to "%color." Before executing the /set command, thus the final variable looks like this:
```
%color.John blue
```

Retrieving Values[edit]

Static Variables

Retrieving values from static variables is pretty straightforward. Let's assume you have a variable called %myvar and it's value is abc, you can get this value simply by referring to the variable outright:

alias showVar {
  echo -a Here is the value of % $+ myvar: %myvar
}

Simply put, this will echo the following to the active window where you typed the /showVar command:

Here is the value of %myvar: abc

Dynamic Variables

Retrieving a value from a dynamic variable is a little bit more complicated. There are two ways.

1. Using Bracket evaluation [ ]

%<static> [ $+ [ <dynamic> ] ]

This is the evaluation brackets method. They allow us to force mIRC to evaluate part of a statement before anything else. Take a look at the rest of the myColor script:

on *:text:!favColor *:#:{
  var %color = %color. [ $+ [ $2 ] ]
  if (%color != $null) {
    notice $nick $2's favorite color is %color $+ .
  }
  else {
    notice $nick $2 doesn't have a favorite color set yet.
  }
}

In the example above, we retrieved the color from the dynamic variable and set it to a local variable called %color for use in the rest of the script. Let's take a closer look at the retrieval statement:

var %color = %color. [ $+ [ $2 ] ]

When you first glance at this statement, it might look a bit confusing, but in fact it is pretty straightforward. Let us continue with John's example and assume someone else typed !favColor John:

The first thing mIRC will evaluate is the innermost evaluation brackets [ ], in this case its $2, which will evaluate to John.
```
%color. [ $+ John ]
```
mIRC will then evaluate the outer evaluation bracket "$+ John".
%color.John

Here is another example:

alias varExample {
  var %array.1 = Item A
  var %array.2 = Item B
  var %array.3 = Item C
  var %array.4 = Item D
  var %array.5 = Item E
  var %x = 1
  while (%x <= 5) {
    echo -a %x = %array. [ $+ [ %x ] ]
    inc %x
  }
}

The above code will echo the following:

1 = Item A
2 = Item B
3 = Item C
4 = Item D
5 = Item E

What this does is create a bunch of static variables, each with ascending-ordered numerical digits. You will notice we used the evaluation brackets around the variable counter, %x. This allows mIRC to evaluate the variable, and attach it to the static portion of %array.. Basically, during run-time, whatever the %x variable's value is will be automatically appended to %array..

Note: If you have multiple dynamic variable to add together, you need to add another pair of $+ [ ... ] for each element or use [ [ $var(%var,1) ] ] :

 %static [ $+ [ %dynamic1 $+ [ %dynamic2 ] ] ]
 %static [ $+ [ %dynamic1 $+ [ %dynamic2 $+ [ %dynamic3 ] ] ] ]
 [ [ $var(static. $+ %dynamic1 $+ %dynamic2,1) ] ]
 etc..

2. Using $eval

You can also get the value of a dynamic variable by using $eval.

$eval allows you to force an expression to evaluate more than once, a bit like the brackets [ ], but brackets are meant to alter the order of evaluation of a line, which itself can have its own drawbacks.

$eval($+(%,<static>,<dynamic>),2)

From our earlier example:

var %color = %color. [ $+ [ $2 ] ]

is the same as

var %color = $eval($+(%,color.,$2),2)

$+(%,color.,$2) will produce the plain text "%color.John", and that is then evaluated a second time (the 2 in $eval(,2)) to produce the value of the variable just like usual. Note that with the brackets method, you also get a double evaluation, but they happen at a different levels.

This method is easier to read/handle than the bracket, you can simply get the plain text variable you want with $+(), and then you evaluate that twice to get the content of the variable, this method is recommended, but note that it's a bit slower than the bracket.

Note: $eval is often used in the simple form $()

Special behaviors & quirks[edit]

Variables routines are a bit special because usually, the first argument given to a variables related command is a variable name, yet mIRC doesn't evaluate it.

Indeed if //echo %var would display its content, it's because %var is evaluated and then passed as the parameter to the /echo command. %Variable related commands are obviously not doing that otherwise the content of the variable or $null would be passed to the command. So mIRC, on purpose doesn't evaluate the variable name.

Quirks in /var[edit]

If most commands cannot preserve spaces, /var can preserve spaces in all situations except if you provide a single trailing space:

//var -s %a $+($chr(32),a,$chr(32),$chr(32),b,$chr(32),$chr(32)),%b $+($chr(32),a,$chr(32),$chr(32),b,$chr(32)) | echo -a $len(%a) $len(%b)

which is displaying 7 5 instead of 7 6 (there is one less space at the end, which is lost because it's a single trailing space), you can use the new -p switch to fix this.

/var is calling /set for every assignment, but every assignment in /var must start with a %

 //var -s %a,$+(%,b) 1

This will set the variable '%a,$+(%,b)' to the value 1, mIRC will consider your second assigment invalid and therefore it's just part of the current variable name.

 //var -s $+(%,b) 1,%a 2

Here the first assignment is ignored and %a is set to 2 properly, it it still possible to construct dynamic variable name by making the % the first character:

 //var -s % $+ b 1

And just like /set, /var will combine $+ with the variable name:

 //var -s %a $+ b value

Does set %ab, evaluation brackets are not required to properly set the variable %ab

/var is also strict on switches, you cannot pass switches dynamically:

 //var %var s | var -g $+ %var % $+ setting 1 | echo -ag > %var -- %setting

or

  //var %var s | var -g $+ %var %setting 1 | echo -ag > %var -- %setting

is not doing the trick

Quirks in /set /inc and /dec[edit]

/set /inc and /dec is less strict than /var, the assignment does not have to start with a %:

 //set -ls $+(%,a) 1

works correctly, however /set also allow dynamic switches, this leads to a new quirk for /set:

//var %var 1 | set -u $+ %var %setting

should set %setting but won't, you can use % $+ setting to workaround this issue.

Quirks in /unset[edit]

/unset can unset a variable not starting with a variable name:

 //var %ab 1,%i 1 | unset -s $var(%ab*,%i) | echo -ag nope | unset -s $var(%ab*,$(%i))

/unset suffers from an evaluation problem, a common problem is using the same logic as /set, for example:

//var -s %a a,%b b,%ab,%a%b | unset -s %a $+ %b

You might expect this to evaluate %b and stick its content to plain text "%a", just like in /set etc but it won't, mIRC won't evaluate %b at all, thinking it's a seperate variable name you want to unset as well, unsetting the wrong %a%b instead of %ab.

To workaround this problem, you must use evaluation brackets to force the evaluation:

//var -s %a a,%b b,%ab,%a%b | unset -s %a $+ [ %b ]

Another issue also occurs with variable inside identifier:

 //var %ab 1 | unset -s $+(%a,b)

This will correctly unset the variable %ab, %a is not evaluated inside $+(), you can use $() on the variable to force evaluation.

Conclusion[edit]

Variables are a great resource to have at your fingertips within mIRC! As you've seen, they are very powerful, and yet don't require too much of a headache to understand :)

@@ Line 1: / Line 1: @@
-{{Template:mIRC Guide}}
+{{mirc title|Variables}}
-{{DISPLAYTITLE:Variables - mIRC}}
 '''mIRC variables''' are items which can hold data temporarily, or permanently, for use at a later time.. You can create, edit, or delete them at any time. All mIRC variables must be prefixed with a % sigil (example %var or %cookies). Variables are untyped – therefore capable of storing letters, numbers, or strings at any given point.
@@ Line 9: / Line 8: @@
 === Local Variables ===
-'''Local Variables''' are given local scope. They are created for the duration of the script that made them and they can only be accessed from within the code line, or block in which they were created in. Once the script has finished, the variable is deleted.
+'''Local Variables''' are given local scope. They are created for the duration of the routine that created them and they can only be accessed from within that routine  Once the routine is finished, the variable is deleted. A routine represents an alias, an event, a menu, or when you execute code with two /slash from the editbox.
+'''Note''': Local variables can be seen from the execution of /scon or /scid: //var %a ok | scon -r echo -a $ + %a ($1- can't be seen the same way)
 Syntax:
@@ Line 60: / Line 61: @@
 '''Practical use:''' a global variable is good for storing variables that you will need to use in the future from another script or at different time. (Login System, Away System, Sockets, Etc...)
+== Semi global ==
+You can use set -u0 to create a variable that can be seen by any routine (global) but is destroyed when the scripting engine exits (when all routines are done), like binary variables.
 == The equal sign '=' ==
@@ Line 81: / Line 86: @@
 unset %var1 %var2 %var3</syntaxhighlight>
-The /unset command supports wildcard characters to be able to unset multiple variables. For example:
+The /unset command supports {{mirc|wildcard}} characters for each of the variable, to be able to unset multiple variables. For example:
 <syntaxhighlight lang="mirc">alias unsetWildExample {
    set %exampleHello hello there
-   set %exampleTest another var
+   set %exampleHey another var
    set %exampleVar yet another var
+  /*
+   Illustrating that each variable can be a wildcard
+   unset -s %exampleH* %exampleVar
+  */
    ;unset all of them
    unset %example*
 }</syntaxhighlight>
 You can also unset all of the variables using the '''/unsetall''' command.
@@ Line 103: / Line 115: @@
    ; make sure our variable doesn't exist
    unset %example1
-   if (%example == $null) {
+   if (%example1 == $null) {
      echo -a % $+ example1 is null!
    }
@@ Line 121: / Line 133: @@
 You can do one math operation with variable when setting a value.
-The operators supported are: '+' '-' '/' '*' '%' '^' where % id the modulus and ^ is power.
+The operators supported are: '+' '-' '/' '*' '%' '^' where % is the modulus and ^ is power.
-You must use a space around all parameters and you must provide correct values, numbers can be float.
+You must use a space around all 3 parameters and you must provide correct values, numbers can be float.
-If you don't respect the format, it will set the value as plain text, use -n to override this behavior when dynamic content.
+If you don't respect the format, it will set the value as plain text, use -n or -p to override this behavior when dynamic content.
+It also supports '&' as the logical-AND operator, but it's supported differently than how $and() handles inputs. Here, the output is valid only if the inputs are valid within the signed 32-bit range. If 1 input is valid and the other is >= 2^31, the result is zero. If 1 input is valid and the other is < -2^31, the result is always -2^31. Unlike how $and casts negative results into an integer in the range 2^31 <= n < 2^32, var can output negative numbers.
 For Example:
@@ Line 219: / Line 233: @@
 '''Dynamic Variables'''
-Retrieving a value from a dynamic variable is a little bit more complicated. There are two ways:
+Retrieving a value from a dynamic variable is a little bit more complicated. There are two ways.
+. Using Bracket evaluation [ ]
 <syntaxhighlight lang="mirc">%<static> [ $+ [ <dynamic> ] ]</syntaxhighlight>
@@ Line 269: / Line 285: @@
 What this does is create a bunch of static variables, each with ascending-ordered numerical digits. You will notice we used the evaluation brackets around the variable counter, ''%x''. This allows mIRC to evaluate the variable, and attach it to the static portion of ''%array.''. Basically, during run-time, whatever the ''%x'' variable's value is will be automatically appended to ''%array.''.
-You can also get the value of a dynamic variable by using [[$eval - Identifier|$eval]], $eval allows you to force an expression to evaluate more than once, a bit like the brackets [ ], but brackets are meant to alter the order of evaluation of a line, which itself can have its own drawbacks.
+'''Note''': If you have multiple dynamic variable to add together, you need to add another pair of $+ [ ... ] for each element or use [ [ $var(%var,1) ] ] :
+  %static [ $+ [ %dynamic1 $+ [ %dynamic2 ] ] ]
+  %static [ $+ [ %dynamic1 $+ [ %dynamic2 $+ [ %dynamic3 ] ] ] ]
+  [ [ $var(static. $+ %dynamic1 $+ %dynamic2,1) ] ]
+  etc..
+. Using $eval
+You can also get the value of a dynamic variable by using {{mIRC|$eval}}.
+$eval allows you to force an expression to evaluate more than once, a bit like the brackets [ ], but brackets are meant to alter the order of evaluation of a line, which itself can have its own drawbacks.
 <syntaxhighlight lang="mirc">$eval($+(%,<static>,<dynamic>),2)</syntaxhighlight>From our earlier example:
 <syntaxhighlight lang="mirc">var %color = %color. [ $+ [ $2 ] ]</syntaxhighlight>
 is the same as
 <syntaxhighlight lang="mirc">var %color = $eval($+(%,color.,$2),2)</syntaxhighlight>$+(%,color.,$2) will produce the plain text "%color.John", and that is then evaluated a second time (the 2 in $eval(,2)) to produce the value of the variable just like usual. Note that with the brackets method, you also get a double evaluation, but they happen at a different levels.
+This method is easier to read/handle than the bracket, you can simply get the plain text variable you want with $+(), and then you evaluate that twice to get the content of the variable, this method is recommended, but note that it's a bit slower than the bracket.
 '''Note''': $eval is often used in the simple form $()
@@ Line 281: / Line 315: @@
 Variables routines are a bit special because usually, the first argument given to a variables related command is a variable name, yet mIRC doesn't evaluate it.
-Indeed if //echo %var would display its content, it's because %var is evaluated and then passed as the parameter to the /echo command. //var %var is obviously not doing that otherwise the content of the variable or $null would be passed to it. So mIRC, on purpose doesn't evaluate the variable name, but it will fail to do so in some case, when the arguments are dynamically passed for example:
+Indeed if //echo %var would display its content, it's because %var is evaluated and then passed as the parameter to the /echo command. %Variable related commands are obviously not doing that otherwise the content of the variable or $null would be passed to the command. So mIRC, on purpose doesn't evaluate the variable name.
-<syntaxhighlight lang="mirc">//set -u $+ %var %setting</syntaxhighlight>which should set %setting but won't, because it gets evaluated, you need to use % $+ setting here, /inc & /dec are most likely affected the same way.
-/unset also suffers from an evaluation problem, due to its ability to unset more than one variable on the same line, there is an issue when trying to unset a variable dynamically from a variable:
+=== Quirks in /var ===
-<syntaxhighlight lang="mirc">//var -s %a a,%b b,%ab,%a%b | unset -s %a $+ %b</syntaxhighlight>You might expect this to evaluate %b and stick its content to plain text "%a", just like in //var -s %a $+ %b, but it won't, mIRC won't evaluate %b at all, thinking it's a seperate variable name you want to unset as well, unsetting the wrong %a%b instead of %ab.
+If most commands cannot preserve spaces, /var can preserve spaces in all situations except if you provide a single trailing space:
+<syntaxhighlight lang="mirc">//var -s %a $+($chr(32),a,$chr(32),$chr(32),b,$chr(32),$chr(32)),%b $+($chr(32),a,$chr(32),$chr(32),b,$chr(32)) | echo -a $len(%a) $len(%b)</syntaxhighlight>which is displaying 7 5 instead of 7 6 (there is one less space at the end, which is lost because it's a single trailing space), you can use the new -p switch to fix this.
+/var is calling /set for every assignment, but every assignment in /var must start with a %
+  //var -s %a,$+(%,b) 1
+This will set the variable '%a,$+(%,b)' to the value 1, mIRC will consider your second assigment invalid and therefore it's just part of the current variable name.
+  //var -s $+(%,b) 1,%a 2
+Here the first assignment is ignored and %a is set to 2 properly, it it still possible to construct dynamic variable name by making the % the first character:
+  //var -s % $+ b 1
+And just like /set, /var will combine $+ with the variable name:
+  //var -s %a $+ b value
+Does set %ab, evaluation brackets are not required to properly set the variable %ab
+/var is also strict on switches, you cannot pass switches dynamically:
+  //var %var s | var -g $+ %var % $+ setting 1 | echo -ag > %var -- %setting
+or
+   //var %var s | var -g $+ %var %setting 1 | echo -ag > %var -- %setting
+is not doing the trick
+=== Quirks in /set /inc and /dec ===
+/set /inc and /dec is less strict than /var, the assignment does not have to start with a %:
+  //set -ls $+(%,a) 1
+works correctly, however /set also allow dynamic switches, this leads to a new quirk for /set:
+<syntaxhighlight lang="mirc">//var %var 1 | set -u $+ %var %setting</syntaxhighlight>should set %setting but won't, you can use % $+ setting to workaround this issue.
+=== Quirks in /unset ===
+/unset can unset a variable not starting with a variable name:
+  //var %ab 1,%i 1 | unset -s $var(%ab*,%i) | echo -ag nope | unset -s $var(%ab*,$(%i))
+/unset suffers from an evaluation problem, a common problem is using the same logic as /set, for example:
+<syntaxhighlight lang="mirc">//var -s %a a,%b b,%ab,%a%b | unset -s %a $+ %b</syntaxhighlight>You might expect this to evaluate %b and stick its content to plain text "%a", just like in /set etc but it won't, mIRC won't evaluate %b at all, thinking it's a seperate variable name you want to unset as well, unsetting the wrong %a%b instead of %ab.
 To workaround this problem, you must use evaluation brackets to force the evaluation:
 <syntaxhighlight lang="mirc">//var -s %a a,%b b,%ab,%a%b | unset -s %a $+ [ %b ]</syntaxhighlight>
-If most commands cannot preserve spaces, /var can preserve spaces in all situations except if you provide a single trailing space:
+Another issue also occurs with variable inside identifier:
-<syntaxhighlight lang="mirc">//var -s %a $+($chr(32),a,$chr(32),$chr(32),b,$chr(32),$chr(32)),%b $+($chr(32),a,$chr(32),$chr(32),b,$chr(32)) | echo -a $len(%a) $len(%b)</syntaxhighlight>which is displaying 7 5 instead of 7 6 (there is one less space at the end, which is lost because it's a single trailing space)
+  //var %ab 1 | unset -s $+(%a,b)
+This will correctly unset the variable %ab, %a is not evaluated inside $+(), you can use $() on the variable to force evaluation.
+== Conclusion ==
 Variables are a great resource to have at your fingertips within mIRC! As you've seen, they are very powerful, and yet don't require too much of a headache to understand :)
-[[Category:mIRC]]
+[[Category:mIRC|variables]]

WikiChip

The Fuse Coverage

Social Media

Companies

Microarchitectures

Technology Nodes

Intel

AMD

ARM

Cavium

Samsung

Intel

AMD

Ampere

Apple

Cavium

HiSilicon

MediaTek

NXP

Qualcomm

Renesas

Samsung

Latest revision as of 05:09, 5 June 2022

Contents

Variable Scope: Global vs. Local[edit]

Local Variables[edit]

Global Variables[edit]

Semi global[edit]

The equal sign '='[edit]

Unsetting Variables[edit]

Syntax:[edit]

$null values[edit]

Math Operations[edit]

Others Commands[edit]

Dynamic Variable Names[edit]

Setting Values[edit]

Retrieving Values[edit]

Special behaviors & quirks[edit]

Quirks in /var[edit]

Quirks in /set /inc and /dec[edit]

Quirks in /unset[edit]

Conclusion[edit]