var Value1, Value2 : double;
Value1 = 224.58;
Value2 = 1548.26;
print("Value 1 = ");
print(Value1);
print("Value 2 = ");
print(Value2);
This would produce:
Value 1 = 224.58 Value 2 = 1548.26
|
Single-Quote '
|
|
The single quote is used to include one character to
initialize, or assign a symbol to, a variable declared as char. A single
is usually combined with another and a character is included between them. Here
is an example:
var Gender : char;
var FirstName, LastName, FullName : String ;
Gender = 'M';
print(Gender);
You can include only one character between single-quotes
except if the combination of symbols can be evaluated to one character. This is
the case for escape sequences. Here is an example:
print('\n');
The double-quote " is used to delimit a string. Like
the single-quote, the double-quote is usually combined with another. Between the
combination of double-quotes, you can include an empty space, a character, a
word, or a group of words, making it a string. Here is an example:
print("The Wonderful World of JScript.NET!!!");
A double-quoted string can also be declared and then
assigned to a variable.
|
|
Square Brackets [ ]
|
|
Square brackets are mostly used to control the dimension or index of an
array. We will learn how to use them when we study arrays.
Here is an example from a future lesson:
var number : double[] = new double[5]; number[0] = 12.44; number[1] = 525.38; number[2] = 6.28; number[3] = 2448.32; number[4] = 632.04;
Algebra uses a type of ruler to classify
numbers. This ruler has a middle position of zero. The numbers on the
left side of the 0 are
referred to as negative while the numbers on the right side of the
rulers are considered positive:
A value on the right side of 0 is considered
positive. To express that a number is positive, you can write a + sign
on its left. Examples are +4, +228, +90335. In this case the + symbol is
called a unary operator because it acts on only one operand.
The positive unary operator, when used, must be positioned on the
left side of its
operand, never on the right side.
As a mathematical convention, when a value is
positive, you don't need to express it with the + operator. Just writing
the number without any symbol signifies that the number is positive.
Therefore, the numbers +4, +228, and +90335 can be, and are better,
expressed as 4, 228, 90335. Because the value doesn't display a sign, it
is referred as
unsigned.
To express a variable as positive or unsigned, you can just type it. here is an example:
print(+802);
This would produce:
Number = 802
As you can see on the above ruler, in order to
express any number on the left side of 0, it must be appended with a
sign, namely the - symbol. Examples are -12, -448, -32706. A value
accompanied by - is referred to as negative.
The - sign must be typed on the left side of the number it is used to
negate.
Remember that if a number does not have a sign, it is considered
positive. Therefore, whenever a number is negative, it
MUST have a - sign. In the same way, if you want to change a value
from positive to negative, you can just add a - sign to its left.
Here is an example that uses two variables. One has a positive value while the other has a negative value: print(-802);
This would produce:
-802 |
|||||||||||||||||||||||||||||||||||||||||||||||||||||||
|
Algebraic Operators
|
|
In algebra, operations are performed on numeric values. Algebraic operators are
represented with the following symbols:
The addition is an operation used to add
things of the same nature one to another, as many as
necessary. Sometimes, the items are added one group to another.
The concept is
still the same, except that this last example is faster. The
addition is performed in mathematics using the + sign. The same
sign is used in C#.
To get the addition of two values, you add the first one to the
other. After the addition of two values has been performed, you get a new value. This
means that if you add Value1 to Value2, you would write Value1 + Value2. The result is another
value we could call Value3. You can also add more than two values, like a + b + c.
With numbers, the order you use to add two or more values doesn't matter. This means
that Value1 + Value2 is the same as Value2 + Value1. In the same way a + b + c is the same as
a + c + b the same as b + a + c and the same as c + b + a
Here is an example that adds two numbers:
print("244 + 835 = ");
print(244 + 835);
Here is the result:
You can also add some values already declared and initialized in
your program. You can also get the values from the user.
In C#, you can also add string variables to add a new
string. The operation is performed as if you were using numbers. For
example, "Pie" + "Chart" would produce "PieChart".
You can also add add as many strings as possible by including the +
operator between them. Here is an example:
var FirstName : String;
var LastName : String;
var FullName : String;
FirstName = "Alexander";
LastName = "Kallack";
FullName = FirstName + " " + LastName;
print(FullName);
This would produce:
Alexander Kallack
The multiplication allows adding one value to itself a certain number
of times, set by a second value. As an example, instead of adding a value to itself in
this manner: A + A + A + A, since the variable a is repeated over and over again, you
could simply find out how many times A is added to itself, then multiply a by that number
which, is this case, is 4. This would mean adding a to itself 4 times, and you would get
the same result.
Just like the addition, the multiplication is associative: a * b * c = c * b * a.
When it comes to programming syntax, the rules we learned with the addition operation also apply to the
multiplication.
Here is an example:
|
var value1 : double;
var value2 : double;
var result : double;
value1 = 224.58;
value2 = 1548.26;
result = value1 * value2;
print(value1 + " * " + value2 + " = " + result);
This would produce:
224.58 * 1548.26 = 347708.2308
|
The Subtraction
|
|
The subtraction operation is used to take out or subtract a value
from another value. It is essentially the opposite of the addition. The subtraction is performed with the -
sign.
Here is an example:
var value1 : double;
var value2 : double;
var result : double;
value1 = 224.58;
value2 = 1548.26;
result = value1 - value2;
print(value1 + " * " + value2 + " = " + result);
This would produce:
224.58 - 1548.26 = -1323.68
Unlike the addition, the subtraction is not associative. In
other words, a - b - c is not the same as c - b - a. Consider the following program
that illustrates this:
// This tests whether the addition is associative
print(" =+= Addition =+=");
print("128 + 42 + 5 = " + (128 + 42 + 5));
print(" 5 + 42 + 128 = " + (5 + 42 + 128));
print();
// This tests whether the subtraction is associative
print(" =-= Subtraction =-=");
print("128 - 42 - 5 = " + (128 - 42 - 5));
print(" 5 - 42 - 128 = " + (5 - 42 - 128));
This would produce:
=+= Addition =+= 128 + 42 + 5 = 175 5 + 42 + 128 = 175 =-= Subtraction =-= 128 - 42 - 5 = 81 5 - 42 - 128 = -165
Notice that both operations of the addition convey the same result.
In the subtraction section, the numbers follow the same order but produce different results.
|
|
The Division
|
|
Dividing an item means cutting it in pieces or fractions of a set value.
For example, when you cut an apple in the middle, you are dividing it
in 2 pieces. If you cut each one of the resulting pieces, you will get 4
pieces or fractions. This is considered that you have divided the apple
in 4 parts.
Therefore, the division is used to get the fraction of one number in
terms of another.
The division is performed with the forward slash /.
Here is an example:
|
var value1 : double; var value2 : double; var result : double; value1 = 224.58; value2 = 1548.26; result = value1 / value2; print(value1 + " * " + value2 + " = " + result);
|
This would produce:
224.58 / 1548.26 = 0.145053156446592
When performing the division, be aware of its many rules. Never
divide by zero (0). Make sure that you know the relationship(s) between the numbers
involved in the operation.
|
|
The Remainder
|
The division program above will give you a result of a number
with decimal values if you type an odd number (like 147), which is fine in some
circumstances. Sometimes you will want to get the value remaining after a division
renders a natural result. Imagine you have 26 kids at a football (soccer) stadium
and they are about to start. You know that you need 11 kids for each team to
start. If the game starts with the right amount of players, how many will seat
and wait?
The remainder operation is performed with the percent sign
(%) which is gotten from pressing Shift + 5.
Here is an example:
var Players : int = 26;
// When the game starts, how many players will wait?.
print("Out of " + Players + " players, " + (26 % 11) + " players will have to wait
when the game starts.\n");
This would produce:
Out of 26 players, 4 players will have to wait when the game starts.
|
JScript.NET Language Operators
|
|
Increment ++
|
Introduction
We are used to counting numbers such as 1, 2, 3, 4, etc. In reality,
when counting such numbers, we are simply adding 1 to a number in order to get the next
number in the range. The simplest technique of incrementing a value consists of adding
1 to it. After adding 1, the value or the variable is (permanently) modified and the
variable would hold the new value. This is illustrated in the following example:
var value : int = 12;
print("Techniques of incrementing a value");
print("Value = " + value);
value = value + 1;
print("Value = " + value);
|
This would produce:
|
Techniques of incrementing a value Value = 12 Value = 13 |
JScript.NET provides a special operator that takes care of this operation.
The operator is called the increment operator and is represented by ++. Instead of
writing Value = Value + 1, you can write Value++ and you would get the same result.
The above program can be re-written as follows:
var value : int = 12;
print("Techniques of incrementing a value");
print("Value = " + value);
value++;
print("Value = " + value);
The ++ is a unary operator because it operates on only one
variable. It is used to modify the value of the variable by adding 1 to it. Every
time the Value++ is executed, the compiler takes the previous value of the
variable, adds 1 to it, and the variable holds the incremented value:
var value : int = 12;
print("Techniques of incrementing a value");
value++;
print("Value = " + value);
value++;
print("Value = " + value);
value++;
print("Value = " + value);
This would produce:
Techniques of incrementing a value Value = 13 Value = 14 Value = 15 |
Pre and Post-Increment
When using the ++ operator, the position of the operator with
regard to the variable it is modifying can be significant. To increment the value
of the variable before re-using it, you should position the operator on the left
of the variable:
var value : int = 12;
print("Techniques of incrementing a value");
print("Value = " + value);
print("Value = " + ++value);
print("Value = " + value);
This would produce:
Techniques of incrementing a value Value = 12 Value = 13 Value = 13 |
When writing ++Value, the value of the variable is incremented before
being called. On the other hand, if you want to first use a variable, then increment it,
in other words, if you want to increment the variable after calling it, position the
increment operator on the right side of the variable:
var value : int = 12;
print("Techniques of incrementing a value");
print("Value = " + value);
print("Value = " + ++value);
print("Value = " + value);
This would produce:
Techniques of incrementing a value Value = 12 Value = 12 Value = 13
|
Decrement --
|
Introduction
When counting numbers backward, such as 8, 7, 6, 5, etc,
we are in fact subtracting 1 from a value in order to get the lesser value.
This operation is referred to as decrementing a
value. This operation works as if a value is decremented by 1, as in Value = Value – 1:
var value : int = 12;
print("Techniques of decrementing a value");
print("Value = " + value);
value = value - 1;
print("Value = " + value);
This would produce:
Techniques of decrementing a value Value = 12 Value = 11
As done to increment, C# provides a quicker way of subtracting 1
from a value. This is done using the decrement operator, that is --. To use the
decrement operator, type –- on the left or the right side of the variable when this
operation is desired. Using the decrement operator, the above program could be
written:
var value : int = 12;
print("Techniques of decrementing a value");
print("Value = " + value);
value--;
print("Value = " + value);
Pre-Decrement
Once again, the position of the operator can be important.
If you want to decrement the variable before calling it, position the decrement
operator on the left side of the operand. This is illustrated in the following
program:
var value : int = 12;
print("Techniques of decrementing a value");
print("Value = " + value);
print("Value = " + --value);
print("Value = " + value);
This would produce:
Techniques of decrementing a value Value = 12 Value = 11 Value = 11
If you plan to decrement a variable only after it has been
accessed, position the operator on the right side of the variable. Here is an
example:
var value : int = 12;
print("Techniques of decrementing a value");
print("Value = " + value);
print("Value = " + value--);
print("Value = " + value);
This would produce:
Techniques of decrementing a value Value = 12 Value = 12 Value = 11
|
Techniques of Incrementing and Decrementing a Variable
|
It is not unusual to add or subtract a constant value to or from
a variable. All you have to do is to declare another variable that would hold the
new value. Here is an example:
var value : double = 12.75;
var newValue : double;
print("Techniques of incrementing and decrementing a value");
print("Value = " + value);
newValue = value + 2.42;
print("Value = " + newValue);
This would produce:
Techniques of incrementing and decrementing a value Value = 12.75 Value = 15.17
The above technique requires that you use an extra variable in
your application. The advantage is that each value can hold its own value although
the value of the second variable depends on whatever would happen to the original
or source variable.
Sometimes in your program you will not need to keep the original
value of the source variable. You may want to permanently modify the value that a
variable is holding. In this case you can perform the addition operation directly
on the variable by adding the desired value to the variable. This operation modifies
whatever value a variable is holding and does not need an additional variable.
To add a value to a variable and change the value that the variable is holding,
you can combine the assignment “=” and the addition “+” operators to produce a new operator as +=
Here is an example:
var value : double = 12.75;
print("Techniques of incrementing and decrementing a value");
print("Value = " + value);
value += 2.42;
print("Value = " + value);
This program produces the same result as the previous. To decrement
the value of a variable, instead of the addition, use the subtraction and apply the
same technique. In the above program, the variable can have its value decremented by
combining the assignment and the subtraction operations on the variable. This is done
with the -= operator. Here is an example:
var value : double = 12.75;
print("Techniques of incrementing and decrementing a value");
print("Value = " + value);
value -= 2.42;
print("Value = " + value);
This would produce:
Techniques of incrementing and decrementing a value Value = 12.75 Value = 10.33
|
Operator Precedence and Direction
|
When combining operations in C#, there are two aspects involved:
an operator's precedence and its direction. If you ask the compiler to add two
numbers, for example 240 + 65, it will execute the operation by adding 240 to 65.
In other words, it would read 240, then +, then 65, and evaluate the result. This
is considered as operating from left to right: 240 -> + -> 65. This process is
referred to as the direction of the operation.
As you will regularly combine operators on your various
calculations, each operation is known for how much it "weighs" as compared to other
operators. This is known as its precedence. This means that when a certain operator
is combined with another, such as a + b * c, or x / y - z, some operators would
execute before others, almost regardless of how you write the operation. That's
why an operator could be categorized by its level of precedence.
One way you can avoid being concerned by the level of precedence
of operator is by using parentheses to tell the compiler how to proceed with the
operations, that is, what operation should (must) be performed first. Consider the
following algebraic operation:
154 - 12 + 8
The question here is to know whether you want to subtract the
addition of 12 and 8 from 154 or you want to add the difference between 154 and 12
to 8. Using parentheses, you can
communicate your intentions to the compiler. This is illustrated in the following program:
var Operation1 : int;
var Operation2 : int;
Operation1 = (154 - 12) + 8;
Operation2 = 154 - (12 + 8);
print("Examining the effect of the parentheses in an operation");
print("(154 - 12) + 8 = " + Operation1);
print(" 154 - (12 + 8) = " + Operation2);
This would produce:
Examining the effect of the parentheses in an operation (154 - 12) + 8 = 150 154 - (12 + 8) = 134
As you can see, using the parentheses controls how the whole operation would
proceed. This difference can be even more accentuated if your operation includes 3 or more
operators and 4 or more operands.
No comments:
Post a Comment