11:52
Dart Basics - Arithmetic operations in Dart
Johan Jurrius
Overview
This video introduces fundamental arithmetic operations in the Dart programming language. It covers basic mathematical operators like addition, subtraction, multiplication, and division, including how Dart handles integer and floating-point division. The video also explains augmented assignment operators, which provide shorthand for common operations, and the concepts of incrementing and decrementing variables using both augmented assignment and dedicated increment/decrement operators. Finally, it differentiates between pre-increment/decrement and post-increment/decrement operators, highlighting their distinct behaviors.
How was this?
Save this permanently with flashcards, quizzes, and AI chat
Chapters
- Dart supports standard arithmetic operations: addition (+), subtraction (-), multiplication (*), and division (/).
- Division (/) on integers can result in a double (floating-point number) if the result is not a whole number (e.g., 6 / 4 results in 1.5).
- Integer division (using `~/`) discards the decimal part, returning only the whole number result (e.g., 6 ~/ 4 results in 1).
- The modulus operator (%) returns the remainder of a division (e.g., 6 % 4 results in 2).
Understanding these basic operators is crucial for performing calculations and manipulating numerical data in any programming task.
Calculating `6 / 4` yields `1.5`, while `6 ~/ 4` yields `1` (the integer part), and `6 % 4` yields `2` (the remainder).
- Augmented assignment operators provide a concise way to update a variable's value based on an operation.
- Operators like `+=`, `-=`, `*=`, `/=`, `~/=`, and `%=` combine an arithmetic operation with assignment.
- For example, `x += 4` is a shorthand for `x = x + 4`.
- Note: For division (`/=`) to work correctly with non-integer results, the variable should be declared as a `double`.
These operators make code shorter and more readable, which is a common practice in software development.
Instead of writing `int x = 5; x = x + 4;`, you can write `int x = 5; x += 4;` to achieve the same result (x becomes 9).
- Increment operators (`++`) add 1 to a variable, while decrement operators (`--`) subtract 1.
- These can be used as augmented assignment operators (e.g., `variable += 1` or `variable -= 1`).
- Dedicated increment/decrement operators (`++variable`, `variable++`, `--variable`, `variable--`) offer even more concise syntax.
- The placement of the operator (before or after the variable) determines whether the operation happens before or after the value is used in an expression (pre- vs. post-increment/decrement).
Efficiently modifying counters or tracking changes is a frequent requirement, and these operators provide specialized tools for that.
To increase `peopleAtShop` by one, you can use `peopleAtShop++` or `++peopleAtShop`.
- Pre-increment (`++variable`): Increments the variable's value *before* it is used in the current expression.
- Post-increment (`variable++`): Uses the variable's current value in the expression *before* incrementing it.
- The same logic applies to pre-decrement (`--variable`) and post-decrement (`variable--`).
- When used in a standalone statement (like `print(++y)` or `y++;`), both pre and post increment/decrement ultimately change the variable's value by one, but their behavior differs within larger expressions.
Understanding this distinction is critical for avoiding subtle bugs when the increment or decrement operation is part of a larger calculation or statement.
If `y` is 10: `print(++y)` prints `11` (y becomes 11 first, then printed). `print(y++)` prints `10` (y is printed first, then becomes 11).
Key takeaways
- Dart provides standard arithmetic operators for basic mathematical calculations.
- Integer division (`~/`) and the modulus operator (`%`) are useful for specific numerical tasks.
- Augmented assignment operators (`+=`, `-=`, etc.) shorten code by combining operations and assignments.
- Increment (`++`) and decrement (`--`) operators are efficient ways to add or subtract one from a variable.
- The position of the increment/decrement operator (prefix vs. postfix) affects when the value is updated relative to its use in an expression.
- Mastering these operators is fundamental for writing clear, efficient, and correct Dart code.
Key terms
Arithmetic OperatorsAdditionSubtractionMultiplicationDivisionInteger DivisionModulus OperatorRemainderAugmented Assignment OperatorsIncrement OperatorDecrement OperatorPre-incrementPost-incrementPre-decrementPost-decrement
Test your understanding
- What is the difference between the division operator (/) and the integer division operator (~/) in Dart?
- How do augmented assignment operators like `+=` simplify common programming tasks?
- Explain the purpose of the modulus operator (%) and provide an example of its use.
- What is the core difference in behavior between a pre-increment operator (`++x`) and a post-increment operator (`x++`)?
- When might you choose to use an increment operator (`++`) over the augmented assignment operator (`+= 1`)?