Skip to document
Welcome to StudocuSign in to access the best study resources
Guest user
0followers
HomeMy LibraryAsk AI
  • You don't have any recent items yet.
My Library
  • You don't have any courses yet.
  • You don't have any books yet.
  • You don't have any Studylists yet.

48.5 dart-basics-summary

Flutter
Course

Programming 1 (CS101)

40 Documents
Students shared 40 documents in this course
Academic year: 2021/2022
Uploaded by:
Anonymous Student
This document has been uploaded by a student, just like you, who decided to remain anonymous.
Kabul University

Comments

Please sign in or register to post comments.

Students also viewed

Related documents

Preview text

Dart Basics

Dart Fundamentals You Should Know!

Important

This document is just a short summary of the basics taught in this module! If you

want to learn more/ all about Dart immediately (instead of throughout the course

lectures), you can scroll to the end of this document. There, you find a link to further

resources!

What is Dart?

Dart is an object-oriented programming language developed by Google. Whilst

technically not restricted, it’s primarily used for creating frontend user interfaces for the

web (with AngularDart or Flutter for Web) and mobile apps (Flutter).

It’s under active development, compiled to native machine code (when used for

building mobile apps), inspired by modern features of other programming languages

(mainly Java, JavaScript, C#) and strongly typed.

As already mentioned, Dart is a compiled language. That means, that your code isn’t

executed like you write it, but instead, a compiler parses + transform it (to machine

code).

Variables, Functions, Types

Like pretty much all programming languages, Dart has a couple of core features it

supports - for example:

• Variables to temporarily store data

• Functions to executed code “on demand”

• Types to analyse your code before you run/ test it

Variables are a core building block that allows you store results of other operations - or

any other data you want to use at a later point of time.

var myName = 'Max';
print(myName); // Outputs ‘Max’

In the above snippet, we see how a variable is created (with the help of the var

keyword), how a value is assigned (with the help of the = sign) and how you can then

use the variable - for example to simply out (print) it to the system log.

Regarding the naming, it’s common that you use camelCase notation to name your

variables - and you want to name such that it’s clear what’s “inside of the variable”.

The myName variable is of type string. Why? Because we initially assign a value of type

string to the variable. Instead of var, you could also use the type name to initialise the

variable.

String myName = 'Max';
print(myName); // Outputs ‘Max’

Since Dart is able to infer the type though (because you initialise the variable with a

value - ‘Max’), it’s considered a better practice to use var instead of String.

Technically, both would work though.

But what are types? Types describe the type of data of something - e. of a variable

(you can also use types in other places, see below). Types are a useful feature because

they force you to write clean code and avoid mistakes/ bugs. For example, an addition

might only work with two numbers but not with two strings. With types, you can

ensure that a certain code expression only accepts numbers and the compiler “yells at

you” if you pass wrong data.

Here are some of the core types Dart offers - please note that this list only includes

important types used in this module. Not all types Dart knows!

Besides variables and types of values, you also have another core concept in Dart (and

in basically any other programming language as well): Functions.

Functions allow you to define code snippets which you can call whenever and as often

as you want.

void sayHello(String name) {
print('Hello ' + name);
}
Type Example More Information
String String myName = 'Max'; Holds text. You can use single or
double quotes - just be
consistent once you made your
choice.
num, int, double int age = 30;
double price = 9.
num refers to “number” - there
are two types of numbers in Dart:
Integers (numbers without a
decimal place) and doubles
(numbers with decimal places)
object Person = Person() Generally, everything in Dart is an
object - even an integer. But
objects can also be more
complex, see below.

Here’s an example class definition:

class Person {
var name = 'Max';
var age = 30;
void greet() {
print('Hi, I am ' + name + ' and I am ' + age() + ' years old!';
}
}

In this example, we define a Person class which has two class-level variables (also

called “instance fields” or “properties”) and one class-level function (also called

“method”).

As you can see, we also use types in classes - for both properties (variables) and

methods (functions).

You can also see, that inside of the greet method, we can access the class properties

name and age without issues (age() is used to covert the integer value to

a string whilst outputting it in a longer string).

The class only serves as a blueprint though! On its own, it does not give you an object!

Instead, you can now create objects based on this class:

class Person {
var name = 'Max';
var age = 30;
void greet() {
print('Hi, I am ' + name + ' and I am ' + age() + ' years old!';
}
}
void main() {
var myself = Person();
print(myself); // use the. to access class properties & methods
}

As a side note: The main function is a special function in Dart - it’s the function which

Dart will execute first, when your app starts.

Inside of main, we then create a new object based on Person by using Person(). This

process is called “instantiating the class”, hence we create “an instance of Person”.

The type of myself would then be Person because classes always also act as types!

Constructor Functions

It might look strange that you create an instance of a class (i. you create an object) by

calling the class like a function.

That makes more sense, however, once you understand that each class has a special

method - which you can (but don’t have to) add to it (if you don’t add it, it invisibly has

an empty default method): The constructor method.

Here’s how you would add a constructor to Person:

class Person {
String name;
int age;
Person(String name, int age) {
this = name; // this refers to the “name” property
this = age;
}
void greet() {
print('Hi, I am ' + name + ' and I am ' + age() + ' years old!';
}
}

A constructor method is added by repeating the class name inside of the class and by

basically writing it like a normal class method (without a return type though).

The constructor can (but doesn’t have to) take arguments which you then can use in

the constructor body. Typically, these arguments are then used to initialise some class

properties (in this example name and age). Using such a constructor has the

advantage, that you can create different, individually configured instances of this class

  • all based on the same class but with different values for name and age.
var mySelf = Person('Max', 30);
var someoneElse = Person('Michael', 45);

It can be confusing, that the constructor takes two arguments name and age, when we

also have to class properties with the same names.

It’s important to understand, that Dart has a concept called “Scoping”. It scopes (=

“limits the usage”) name and age received as arguments to inside the constructor

method. I., you can only use name and age inside the constructor method.

name and age on the class level are available in the whole class though. To tell them

apart, you can use this and this to make it clear that you’re referring to

the class-level properties. Without the special this keyword, Dart assumes that you’re

referring to local (method-level) variables named name and age. Only if such variables

would not exist, Dart would fall back to the class-level properties.

In addition, constructors, where you only accept arguments to them assign them to

class properties, can be shortened. By using the shortcut you see above (no

constructor body, ; after the constructor, this. in front of the argument, no types

being used, arguments match property names) you instruct Dart to automatically store

the argument values in the fitting properties of the class.

Positional & Named Arguments

No matter if you’re working with constructor methods, normal methods or normal

functions, you can always accept two types of arguments: Positional and named

arguments.

Thus far (in the above examples), we only used positional arguments - i. the first

value you pass into the function when calling it, is passed into the first argument. The

second value is passed to the second argument etc.

As an alternative, you can use named arguments - those are especially useful if you

got functions with many arguments. Remembering the position of each argument

(when calling the function) can be difficult - using names can be easier, especially since

IDEs like Visual Studio Code help you with completion.

void doSomething({String name, double price, String description}) { ... }

In this example, name, price and description are named arguments - simply by

wrapping the argument list with { }.

You can also mix positional and named arguments, the positional arguments have to

come first though:

void doSomething(String name, {double price, String description}) { ... }

How do you call a function with named (or mixed) arguments?

doSomething('A Book', price: 9, description: 'An awesome book!’);

You “target” a named argument by using it’s name and a colon (:) and then the value

you want to assign.

Named arguments are always optional by default! That means, that you could call a

function/ method without providing a value of the argument. Therefore, you should

ensure that your function works if no value is provided. Or you set a default value:

void doSomething(String name, {double price = 5}) { ... }

When working in a Flutter app, you can also add a so-called “Decorator” to a named

argument that marks it as “required” (it adds metadata behind the scenes that causes

the Dart compiler to “yell at you” if you are not providing a value when calling the

method):

void doSomething(String name, {@required double price}) { ... }

Side-note: You can also have optional positional arguments - also with default values if

you want to:

void doSomething(String name, [double price, String desc = 'Default']) { ... }

Inheritance

Back to classes and objects. One important concept, which you’ll see a lot when

working with Flutter, is “Inheritance”.

“Inheritance” means that a class can be based on another class (and only one one

other class, not on multiple classes).

class Person {
void greet() {
print('Hi!');
}
}
class Friend extends Person {
void greetFriendly() {
print('Amazing to see you!');
}
}
void main() {
var myFriend = Friend();
myFriend(); // works and prints “Hi”
myFriend(); // also works and prints “Amazing to see you!”
}

In this example, Friend is a class that inherits from Person (by using the extend

keyword). The Friend class now has all properties and methods of Person but it can

also add its own properties and methods. On every instance of Friend, you can

therefore use everything you could use on a Person instance, and you can of course

access all features of Friend. Every instance of Friend also automatically is of type

Friend and of type Person!

You can also override methods (and properties) of base/ parent classes:

const values on the other hand are known at the point of time you’re writing the code.

For example some text you want to output in a widget - it might not change at runtime

and hence is compile-time constant.

const title = 'Your Products’; // this can’t change at runtime!

“if” Statements & Ternary Expressions

Quite often in coding, you have certain code that should only run if some condition is

met (or not met).

var age = getFromUserInput(); // assume that this is entered by a user
if (age > 30) {
runCodeForOldUser();
} else if (age < 25) {
runCodeForVeryYoungUser();
} else {
runCodeForUserBetween25and30();
}

if statements allow you to run different code snippets based on one or more

conditions (multiple conditions can be combined with a logical AND - && - or a logical

OR - || -).

You can also define else or else if blocks in an if statement to define code that runs

if the condition is not met (else) or if it’s not met and some other condition is true

(else if).

Where to learn more

This document only touches on some of the basics of Dart - and also only on some

basics that are shown in this module.

Throughout the course, you’ll learn more and more about Dart.

In case you want to learn way more about it right now already - or in case you want to

dive a bit deeper into the things mentioned above - the official docs are a great place

to learn more: dart/guides/language/language-tour

Was this document helpful?

48.5 dart-basics-summary

Course: Programming 1 (CS101)

40 Documents
Students shared 40 documents in this course

University: Kabul University

Was this document helpful?
Dart Basics
Dart Fundamentals You Should Know!
Important!
This document is just a short summary of the basics taught in this module! If you
want to learn more/ all about Dart immediately (instead of throughout the course
lectures), you can scroll to the end of this document. There, you find a link to further
resources!
What is Dart?
Dart is an object-oriented programming language developed by Google. Whilst
technically not restricted, it’s primarily used for creating frontend user interfaces for the
web (with AngularDart or Flutter for Web) and mobile apps (Flutter).
It’s under active development, compiled to native machine code (when used for
building mobile apps), inspired by modern features of other programming languages
(mainly Java, JavaScript, C#) and strongly typed.
As already mentioned, Dart is a compiled language. That means, that your code isn’t
executed like you write it, but instead, a compiler parses + transform it (to machine
code).
Variables, Functions, Types
Like pretty much all programming languages, Dart has a couple of core features it
supports - for example:
•Variables to temporarily store data
•Functions to executed code “on demand”
•Types to analyse your code before you run/ test it
Variables are a core building block that allows you store results of other operations - or
any other data you want to use at a later point of time.
var myName = 'Max';!
print(myName); // Outputs ‘Max’
In the above snippet, we see how a variable is created (with the help of the var
keyword), how a value is assigned (with the help of the = sign) and how you can then
use the variable - for example to simply out (print) it to the system log.
Regarding the naming, it’s common that you use camelCase notation to name your
variables - and you want to name such that it’s clear what’s “inside of the variable”.

Students also viewed

Related documents