Functions
Function is a set of statements that take inputs, do some specific computation and produces output.
Dart is a true object‐oriented language, so even functions are objects and have a type. This means that
functions can be assigned to variables or passed as arguments to other functions.
void main()
{
num myFunction(num n1, num n2) //yellow highlighted part is called as function definition or function signature or
function declaration
// num is the return type which declares that myFunction will return a value of type num
// n1 and n2 are called parameters whose return type are num
{ //function body starts with this curly brackets
If(n1>0) //n1>0 is an expression which returns false or true at runtime according to the value of n1
{
return n1 + n2;
}
} //function body ends with this curly brackets
var number1 = 30; //number1 is annotated with integer type because of type inference properties
var number2 = 40.5; //number1 is annotated with double type because of type inference properties
var result = myFunction(number1, number2);
//yellow highlighted text is a function caller which allows us to call/invoke a function
//number1 and number2 are arguments
print('result is $result');
}
1
greet (String name, String title)
{
print ("hello "+ title+" "+name);
}
void main() {
greet ("Cagdas", "mr.");
}
Return type inference
By looking at the return statement, Dart can infer the type of the return value. Therefore, you don’t need to explicitly specify
the return type as follows, return type inference can infer that greet function returns a value of type string:
2
Classes (blueprint)
Dart is an object‐oriented programming language – which means that every value in Dart is an object,
even primitive values like text (= String) or numbers (=Integers and Doubles). But you also have more
complex built‐in objects (e.g. Lists of data) and you can build your own objects.
You often build your own objects if you want to express more complex relations between data or if you
want to encapsulate certain functionality in “one building block”.
A class in terms of OOP is a blueprint for creating objects. Objects are created with the help of “Classes”
because every object needs a blueprint (i.e., the class) based on which you can then create (“instantiate”)
it.
Here’s an example class definition:
class MyPersonClass{
var myName ='cagdas'; //myName, myAge and yourAge are class‐level variables =instance
fields=properties=attributes
var myAge =39;
var yourAge=33;
void myMethod() { //class level method if a function is defined in a class like this, then it is called method
print ('Hello, this is '+myName+' who is $myAge years old');
print ('Hello, this is $myName who is $myAge years old'); //this line and the above line outputs the same text
print ('Hello, this is $myName who is ${myAge+yourAge} years old'); //it adds the value of myAge to yourAge
}
}
void main() {
num myFunction(num n1, num n2)
{
return n1 + n2;
}
var number1 = 30; //number1 is annotated with integer type because of type inference properties
var number2 = 40.5; //number1 is annotated with double type because of type inference properties
var result = myFunction(number1, number2); //function caller allows us to call/invoke a function
print('result is $result');
var itsMe = MyPersonClass(); //we are instantiating the class, in other words, we are creating an instance of
MyPersonClass
itsMe.myMethod();
}
Camel Case Naming Convention
CamelCase is a naming convention where the first word is always in lowercase and every other word
starts with a capital letter such as myVariable, myPrettySpecialFunction
As a good practice, identifiers are named by following Came Case Naming Convention.
Pascal Case Naming Convention
PascalCase is a naming convention where the first letter in every word is capitalized and the rest is in
lowercase such as MyClass, MyPrettySpecialClass. As a good practice, classes are named by following
Pascal Case Naming Convention.
3
Parameters vs. Arguments
Sometimes, parameters and arguments are used interchangeably. In fact, they’re different. And it’s
important to distinguish between them.
A parameter is a variable that you specify in the function signature when you define the function. For
example, the greet() function has a parameter called name.
An argument is a value or variable that you pass into the function when calling it. For example, the
string literal 'John' is the function argument.
4
Constructors
Constructor is a special method of Dart class which is automatically called when the object is created.
Bu satirda class’in contructor’ini olusturuyoruz; this.age deyince buradaki degiskeni yani class’in
properties’indeki age degiskenini belirtiyoruz. Eger contructor’in parametresindeki değişkenin ismi yani
burası ‘age’ olmasaydi, mesela myAge olsaydı, o zaman bu satırdaki gibi this keywordunu kullanmadan
da yazabilirdik isim çakışması olmayacagi icin.
class Person{
var name;
var age;
Person (String nameOfPerson, int age)
{
name= nameOfPerson;
this.age =age;
}
}
void main() {
var p1 = Person('ali', 23);
print('name of person is ${p1.name} and the age of person is ${p1.age}');
}
5
Her bir variable tanimlandigi block icinde gecerlidir, blogun disinda gecersizdir, bu duruma scoping
deniliyor.
"Scoping" means that you can use the variables only inside of the block statement (= also called
function body if it belongs to a function), the code between the { } where you defined them.
A nested block is a block nested inside of a block. For example, in case of IF , an if block inside of an if
block is a nested if block.
myVariable1 değişkeni tanımlandığı blokta ve eğer varsa bu bloğun kapsadığı inner/nested blocklarda
geçerlidir, yani bu 2 kıvırcık parantezin kapsadığı her yerde geçerlidir; ama örneğin myVariable2
değişkeni outer blockta geçerli değildir
Required Positional parameters (vizede yok)
The term "required" in "required positional parameters" doesn't mean it has to be non‐nullable.
But it means that all arguments must be sent to the parameters. If the parameter is nullable, you have
to send “null” explicitly as an argument.
6
positional parameter durumunda iki parantez arasında paremetreleri virgule ayırarak listeleriz.
Positional parametrelerde parametreler optional degil, yani 2 adet parameter varsa 2 parametreye de
buradaki gibi arguman gönderilmek zorunda. Bu yuzden default deger de atayamiyoruz parametrelere,
argument gondermek zorunda oldugumuz icin. Ayrica burada parametreler hangi siradaysa argument
gönderirken de aynı sırada göndermeliyiz, yukarıdaki örnekteki gibi önce nameofPerson isimli parametre
için bir string argüman, sonra da age isimli parametre için bir integer argüman göndermemiz gerekiyor.
class Person{
var name;
var age;
Person (String nameOfPerson, int age)
{
name= nameOfPerson;
this.age =age;
}
}
void main() {
var p1 = Person('ali', 23);
print('name of person is ${p1.name} and the age of person is ${p1.age}');
}
7
Eğer parametrelerde data type “var” ise o zaman p1 nesnesini oluştururken null argüman da
gönderebiliriz,
Yok eger parametrelerin data type’I “var” harici bir tip olsaydı asagıdaki gibi, o zaman hata verirdi cunku
string ya da integer parametreye null deger atanamaz
Bu hatayı gidermek için aşağıdaki gibi ? operatörüyle parametreyi nullable hale getirebiliriz
8
Named Parameters (vizede yok)
We define named parameters by listing them between curly brackets {}, e.g., {int a, int b, …}.
Named parameters are optional unless they’re explicitly marked as required.
When calling a function, you can specify named arguments using paramName: value.
Named parameter durumunda, positional parameter durumundan farklı olarak, bu kıvırcık parantezler
(curly brackets) arasına yazıyoruz parametreleri
Positional’da parameter sırası önemli, ilk sirada nameOfPerson 2. Sirada ise age argumanlarini
gondermek zorundasin yani “order matters”, ayrıca kac tane parametre varsa her birine argument
göndermek zorundasın
named parameter’lar ise optional’dir (required keyword’ü ile optional olmaktan çıkarmadığın sürece),
yani istediğin parametreye argüman gönderip istemediğine göndermezsin; parametreye argüman
gönderilmediği durumlarda, her bir parametre için, bir varsayılan değer yani default deger belirleyip o
parametreye atayabilirsin. Eger bu default degeri biz belirlemezsek, o zaman sistem default degeri
otomatik sekilde ‘null’ olarak atar. Olur da eger named parametrelerin data type’ını “var” haricinde bir
veri tipiyle mesela int, string, num ile belirlemişsek, o zaman default degerini biz belirlemek zorundayız.
9
burada, diyoruz ki; eger nameOfPerson parametresine arguman gönderilmezse, o zaman default olarak
‘defaultName’ ata.
Burada ise required keyword sayesinde optional ozelligini iptal edebiliyoruz “age” parametresinin,
böylece artik “age” parametresine bir argüman gondermek zorundayız siniftan nesne olustururken,
ancak nameOfPerson parametresine argüman göndermek zorunda değiliz class’I instantiate yaparken, o
hala optional
Required keyword’ünü kullanirsan eğer artik default deger de atayamazsin parametreye, çünkü artık
oraya bir argüman gönderilmek zorunda , optional özelliği ortadan kalkıyor required ile
Beginning with Dart 2.12, the @required annotation is now replaced by the required keyword. You
should mark your field required if it is mandatory for others to send an argument to it.
class Person
{
var name;
var age;
Person ({var nameOfPerson ='defaultName', required var age})
10
{
name= nameOfPerson;
this.age =age;
}
}
void main() {
var p1 = Person(nameOfPerson:'ali', age:23);
var p2 = Person(age:22, nameOfPerson:'veli');
var p3 = Person(age:26);
print('name of person is '+p1.name+' and the age of person is ${p1.age}');
print('name of person is ${p2.name} and the age of person is ${p2.age}');
print('name of person is ${p3.name} and the age of person is ${p3.age}');
}
11
Bu yukardaki sekilde named parameter yaparsan hata verir, neden? Cünkü eger parametrelerin veri
tipini “var” olarak belirtmezsen, yukaridaki gibi string ve int olarak belirtirsen o zaman asagidaki gibi
default degerlerini de belirlemen lazim ki hata vermesin.
Artik hata vermez cunku default degerlerini de belirledik constructorda,
class Person
{
var name;
var age;
Person ({String nameOfPerson ='defaultName', int age=99})
12
{
name= nameOfPerson;
this.age =age;
}
}
void main() {
var p1 = Person(nameOfPerson:'ali', age:23);
var p2 = Person(age:22, nameOfPerson:'veli');
var p3 = Person();
print('name of person is '+p1.name+' and the age of person is ${p1.age}');
print('name of person is ${p2.name} and the age of person is ${p2.age}');
print('name of person is ${p3.name} and the age of person is ${p3.age}');
}
Kodu kisaltmak icin contructor icinde this keyword’ü ile hizli şekilde assign yapabilirsin yukardaki gibi;
name ve age isimli class‐level değişkenlere nesne olusturulurken buralardan gönderilen argümanları
direct assign yapar
13
Optional Named Parameter (vizede yok)
Yukardaki örnekte Constructor parameter listesinde ilk iki parametre required positional parameter, 3.
Parameter ise kivircik parantez arasinda, bu 3. Parametreye optional named parameter denilmekte.
Optional oldugu icin bu parametreye bir arguman gondermek zorunda degiliz (required keyword’ü ile
optional olmaktan çıkarmadığımız sürece), ancak parametrenin data type’ı String olarak belirtildiği için
default degerini girmek zorundayiz. Eger asagidaki ornekteki gibi data taype’ı ‘var’ olsaydi o zaman
default deger girmemize gerek kalmazdi
class Person
{
var name;
var age;
var gender;
Person (String nameOfPerson, int age, {String gender='male'})
{
name= nameOfPerson;
this.age =age;
this.gender=gender;
}
}
void main() {
var p1 = Person('ali', 23);
14
var p2 = Person('veli',14);
var p3 = Person('ayse',34,gender:'female');
print('name of person is '+p1.name+' and the age of person is ${p1.age}');
print('name of person is ${p2.name} and the gender of person is ${p2.gender}');
print('name of person is ${p3.name} and the gender of person is ${p3.gender}');
}
Burasi ‘var ‘ oldugu icin default deger girmesek de olur, kendisi ona varsayilan deger olan NULL degeri
atayabilir artık, aksi taktirde string parametreye NULL degeri atamaya calısacaktı
15
yukarıdaki gibi birden fazla optional named parameter olması durumunda bunlara argüman gönderirken
sıralamanın önemi yok “order does not matter”, buradaki gibi rastgele sıralamayla argüman
gönderebiliriz. Ayrıca optional oldukları için aslında parametrelere argüman göndermek zorunda bile
değiliz
class Person {
var name;
var age;
var gender;
var surname;
var job;
Person(String nameOfPerson, int age, {var gender, var surname, var job}) {
name = nameOfPerson;
this.age = age;
this.gender = gender;
this.surname = surname;
this.job = job;
}
}
void main() {
var p1 = Person('ali', 23);
var p2 = Person('veli', 23, job: 'engineer', gender: 'male');
var p3 = Person('ayse', 34, job: 'teacher');
print('name of person is ' + p1.name + ' and the age of person is ${p1.age}');
print('name of person is ${p2.name} and the job of person is ${p2.job} and the gender of person is ${p2.gender}');
print('name of person is ${p3.name} and the job of person is ${p3.job}');
}
16
Optional Positional Parameter (vizede yok)
Yukarıdaki örnekte ilk iki parameter positional parameter, 3. Parameter ise köseli prantez icinde (square
bracket). Köşeli parantez içindeki parametreye optional positional parameter diyoruz, nesne olusturuken
arguman gondermek zorunda degiliz optional olduğu için (required keyword’ünü kullanarak optional
özelliğini kaldırma olayı optional positional parametrelerde geçerli değil); ancak data type’ı “var”
haricinde bir tip yani String tipinde oldugu icin default deger girmek zorundayız. Asagidaki ornekteki gibi
eger data type ‘var’ olsaydi o zaman default deger girmemize de gerek kalmazdi, cunku default deger
olan null atanabılırdi ‘var’ very tipinde ama string veri tipindeki bir parametreye null deger
atanmayacagı icin data type’ı “var” olmayan tüm parametrelere default degeri bizim atamamız gerekir
bu örnekteki gibi
class Person
{
var name;
var age;
var gender;
Person (String nameOfPerson, int age, [String gender='male'])
{
name= nameOfPerson;
this.age =age;
this.gender=gender;
}
}
17
void main() {
var p1 = Person('ali', 23);
var p2 = Person('veli',14);
var p3 = Person('ayse',34,'female');
print('name of person is '+p1.name+' and the age of person is ${p1.age}');
print('name of person is ${p2.name} and the gender of person is ${p2.gender}');
print('name of person is ${p3.name} and the gender of person is ${p3.gender}');
}
Burası “var” olduğu için default değer girmemize gerek yok, sistemin otomatik olarak belirlediği default
degerı yani “null” degeri gender isimli parametreye atayabilir
18
Eğer yukarıdaki gibi birden fazla optional positional parameter varsa, bu parametrelere argümanları
burada yazan sıraya göre göndermek zorundasın yani “order matters”; önce gender, sonra surname,
sonra job olacak şekilde. Optional oldukları için argüman göndermesen de olur, eger argüman
göndermezsen kendisi otomatik olarak “null” atar parametrelere (data type ‘var’ ise). Bu satırda
argüman ataması yaparken sıra bozulmasın diye surname kısmına “null” değer gönderdim argüman
olarak, eğer bunu yapmasaydım “engineer” argümanını “job” parametresi yerine sıradaki “surname”
parametresine atayacaktı, ve “job” parametresine de varsayılan deger olarak “null” atanacaktı
class Person {
var name;
var age;
var gender;
var surname;
var job;
Person(String nameOfPerson, int age, [var gender, var surname, var job]) {
name = nameOfPerson;
this.age = age;
this.gender = gender;
this.surname = surname;
this.job = job;
}
}
void main() {
var p1 = Person('ali', 23);
var p2 = Person('veli', 23, 'male',null,'engineer');
var p3 = Person('ayse', 34, 'female');
print('name of person is ' + p1.name + ' and the age of person is ${p1.age}');
print('name of person is ${p2.name} and the job of person is ${p2.job} and the gender of person is ${p2.gender}');
print('name of person is ${p3.name} and the age of person is ${p3.age} and the gender of person is ${p3.gender}');
}
19
Optional Named Parameter vs. Optional Positional Parameter (vizede yok)
Optional positional parametrelerde, parametrelere argüman gönderirken sıraya göre göndermen gerekir
“order matters”, optional named parameter durumunda ise sıranın önemi yok “order does not matter”.
Ayrıca optional named parameterlar’da “required” keyword’ü ile parametreyi optional olmaktan
çıkarabiliyorsun ama optional positional parametrelerde “required” keyword’ü geçersiz.
Rules while declaring parameters in Dart (vizede yok)
A function can have any number (zero or more) of required positional parameters.
Then it can be followed either by named parameters or by optional positional parameters (but
not both).
You can't mixed named parameters and optional positional parameters.
void hide(Widget content, {required bool hidden}, [bool? animated]) { ... }
Example:
20
void requiredPositionalParameter(String name, var age, var cage, var rage, var nage) //positional parameter optional degil; default
deger atayamam parametrelere cunku arguman göndermek zorundayız zaten parametrelere, ayrica burada parametreler hangi
siradaysa fonksiyonu cagirirken de ayni sirada argument gondermek zorundayiz
{
print('PositionalParamater‐ Name: $name ‐ Age: $age ‐ cage: $cage ‐ rage: $rage ‐ nage: $nage');
}
void optionalPositionalParameter([String name="cagdas", var age, var cage, var rage, var nage=100]) //optional oldugu icin istersem
default deger atayabiliyorum, eger ben default deger atamak istemezsem o zaman default deger sistem tarafından otomatik sekilde
null olarak atanir. Optional oldugu icin eger 'var' haricinde bir veri tipi ile parametreyi tanimlamissam o zaman default degerini de en
bastan atamak zorundayim tıpkı burada ilk sıradaki name isimli parametredeki gibi. Optional olduğu için fonksiyonu cagirirken tüm
parametrelere argüman göndermek zorunda degilim ama girdigim argumanlari burdaki siraya gore atar, örneğin 3 tane arguman
girdiysem buradaki ilk 3 parametreye atar o degerleri
{
print('OptionalPositionalParameter‐ Name: $name ‐ Age: $age ‐ cage: $cage ‐ rage: $rage ‐ nage: $nage');
}
void optionalPositionalParameterWithPositional(String name, [var age, var cage, var rage, var nage=100]) //ilk parametre required
positional parametre, o yuzden fonksiyonu cagirirken ilk parametreye arguman gondermek zorundayiz, [ ] arasındaki parametrelerde
ise yukarıdakı optionalPositionalParameter fonksiyonunun yorum kısmında yazdıklarım geçerli
{
print('OptionalPositionalParameterwithPositional‐ Name: $name ‐ Age: $age ‐ cage: $cage ‐ rage: $rage ‐ nage: $nage');
}
void optionalNamedParameter({String name='cagdas', var age, var cage, var rage, var nage=100}) //named parameterlar
optional'dir, o yuzden default deger de atayabiliyorum, eger ben atamazsan burada o zaman default deger otomatik sekilde null
olarak atanir sistem tarafindan (not:required keywordu ile optional olmaktan cikarirsan o zaman required olan parametreye default
deger atayamayiz), Ayrica 'var' haricinde bir veri türüyle tanimlarsan paramatreyi yani 'int, string' gibi o zaman default deger atamak
zorundasin; fonksiyonu cagirirken tüm parametrelere birden ve buradaki siraya gore argumnet göndermek zorunda degilim
{
print('OptionalNamedParameter‐ Name: $name ‐ Age: $age ‐ cage: $cage ‐ rage: $rage ‐ nage: $nage');
}
void optionalNamedParameterWithPositional(String name, {var age, var cage, var rage, var nage=100}) //ilk parametre optional
olmayan positional parametre, o yuzden fonksiyonu cagirirken ilk parametreye arguman gondermek zorundayiz, { } arasındaki
parametrelerde ise yukarıdakı optionalNamedParameter fonksiyonunun yorum kısmında yazdıklarım geçerli
{
print('OptionalNamedParameterWithPositional‐ Name: $name ‐ Age: $age ‐ cage: $cage ‐ rage: $rage ‐ nage: $nage');
}
void optionalNamedParameterWithRequired({String name='cagdas', required var age, var cage, var rage, var nage=100}) //required
keywordu ile optional olmaktan cıkardım age isimli parametreyi. Artık optional olmadıgı için default deger giremiyorum cunku
argüman göndermek zorundayım artık age parametresine
{
print('OptionalNamedParameterwithRequired‐ Name: $name ‐ Age: $age ‐ cage: $cage ‐ rage: $rage ‐ nage: $nage');
}
void main() {
requiredPositionalParameter('John',12,23,44,5);
//requiredPositionalParameter(null,null,null,null,null);//hata verir çünki string tipinde veri tutan parametreye null edeger
atayamayız
requiredPositionalParameter('Jack',null,null,null,null);
optionalPositionalParameter();
optionalPositionalParameter('John');
optionalPositionalParameter('John', 12, 23);//2. paramereye 12, 3. parametreye 23 degerini gönderir, diğer parmetrelere otomatik
şekilde null gönderilir
optionalPositionalParameterWithPositional('John');
21
optionalPositionalParameterWithPositional('John', 12, 23);
optionalNamedParameter();
optionalNamedParameter(age:12, name:'John');
optionalNamedParameterWithPositional('John');
optionalNamedParameterWithPositional('John', cage:12, rage:23);
optionalNamedParameterWithRequired(age:33);
optionalNamedParameterWithRequired(age:33, cage:12, name:'John', rage:23);
}
Output:
PositionalParamater‐ Name: John ‐ Age: 12 ‐ cage: 23 ‐ rage: 44 ‐ nage: 5
PositionalParamater‐ Name: Jack ‐ Age: null ‐ cage: null ‐ rage: null ‐ nage: null
OptionalPositionalParameter‐ Name: cagdas ‐ Age: null ‐ cage: null ‐ rage: null ‐ nage: 100
OptionalPositionalParameter‐ Name: John ‐ Age: null ‐ cage: null ‐ rage: null ‐ nage: 100
OptionalPositionalParameter‐ Name: John ‐ Age: 12 ‐ cage: 23 ‐ rage: null ‐ nage: 100
OptionalPositionalParameterwithPositional‐ Name: John ‐ Age: null ‐ cage: null ‐ rage: null ‐ nage: 100
OptionalPositionalParameterwithPositional‐ Name: John ‐ Age: 12 ‐ cage: 23 ‐ rage: null ‐ nage: 100
OptionalNamedParameter‐ Name: cagdas ‐ Age: null ‐ cage: null ‐ rage: null ‐ nage: 100
OptionalNamedParameter‐ Name: John ‐ Age: 12 ‐ cage: null ‐ rage: null ‐ nage: 100
OptionalNamedParameterWithPositional‐ Name: John ‐ Age: null ‐ cage: null ‐ rage: null ‐ nage: 100
OptionalNamedParameterWithPositional‐ Name: John ‐ Age: null ‐ cage: 12 ‐ rage: 23 ‐ nage: 100
OptionalNamedParameterwithRequired‐ Name: cagdas ‐ Age: 33 ‐ cage: null ‐ rage: null ‐ nage: 100
OptionalNamedParameterwithRequired‐ Name: John ‐ Age: 33 ‐ cage: 12 ‐ rage: 23 ‐ nage: 100
22
