DEV Community: Raphael Kihiro

Functions in dart

Raphael Kihiro — Mon, 10 Nov 2025 07:03:01 +0000

1. Introduction

Functions are a fundamental construct in programming languages, enabling, code reusability, and improved maintainability. This in this segment I will dive into the definition, structure, and invocation of functions in Dart, highlighting their syntax and purpose within program design.

1.1 Function Definition.
A function in Dart is defined as a reusable block of code designed to execute a specific operation. The general syntax of a function is as follows:

In this example:

greet denotes the function name, which serves as the identifier for invocation.
The parentheses() may contain parameters,
The curly braces {} enclose the function body,

For a function to be executed it has to be invoked(called);

To execute the Dart file, run the commanddart run(file name), in the terminal:

When executed, this program prints:

2. Structure of a Function

2.1 The main() Function in Dart

In Dart, every standalone program must have a main() function, that serves as the entry point of the program. Without this function, Dart cannot determine where to start execution, leading to a runtime error.

When you attempt to run a Dart program without defining a main() function, the following error appears:

2.1.1 Syntax of the main() Function
The main() function has a simple and well-defined syntax. It’s also important to note that themain()function returns void, meaning it does not have a return value.

2.1.2 Example of the main() Function Calling Another Function
Here is an example demonstrating on how the main() function interacts with other functions:

The greet() function is defined to return a string value('hello dart learner').The main() function calls greet() using print(greet());.
And the expected output is;

2.2 Functions as First-Class Objects in Dart

In Dart, functions are first-class objects, meaning they can be treated just like any other variable or object in the language. This gives functions in Dart the following characteristics;

Be stored in a variable,
Be passed to another function as an argument, and
Be returned from another function.

2.2.1 Assigning a Function to a Variable
A function can be assigned to a variable, allowing it to be called later using that variable name.

The image above show a random function sayHello().
Continuation on the same

Here, the function sayHello() is assigned to a variable greetFunc. This allows you to call the function later using the variable name instead of the original function name.
When you call greetFunc(), the output will be:

2.2.2 Passing a Function to Another Function

Functions in Dart can also be passed as arguments to other functions.
This is particularly useful for callbacks, event handling, and customizing behavior dynamically.

Here’s a visual illustration of passing a function as an argument:

The expected output;

2.2.3. Functions with a return value
A function can also return a value after performing its task.
If a function is declared as void, it means it does not return anything.

Here is the output when the function is void;

In the example below, we use the type bool to indicate that the function returns a Boolean value (true or false).

When arguments are passed into the functionisEven() remember we use the print() to have the output displayed on the terminal

The expected output is;

2.3 Parameters in Functions
Parameters act as inputs that a function receives during invocation.

In the illustration above, String name inside the parentheses () is a parameter. That acts as a placeholder for the argument (the actual value) passed during the function call.
Parameters allow the function to process variable data instead of being limited to fixed values.

Expected output:

There several types of parameters used in functions:

2.3.1 Positional Parameters
Positional parameters are the most basic type of function parameters.
They must be passed in the same order they are defined in the function declaration.

When calling the function the order matters.

In the code above, notice the commented-out section — it shows an error caused by incorrect parameter order and if executed this is the output is.

But if the parameters are correctly order the output is;

2.3.2 Named Parameters { }

Named parameters are enclosed in curly braces {} and allow arguments to be specified by name.
This enhances code readability and flexibility, especially when dealing with many parameters.

Named parameters are optional by default, but they can be made required using therequired keyword.

They can also have default values using the = operator.

The image below shows illustrations on the named parameters on different functions being invoked(read the comments they can help guide you)

And the expected outcome respectively;

3. Optional Positional Parameters [ ]

Optional positional parameters allow you to make some function parameters optional by enclosing them in square brackets [ ].
If the caller doesn’t provide a value for these parameters, they take on a default value (if one is specified) or become null by default.

The arguements passed in the function.

Excepted output;

3. Function Scope in Dart

Scope defines where variables and functions can be accessed within a program. Variables can be defined as global, local, or nested, depending on where they are declared.

3.1 Global Scope
A variable declared outside any function or class has global scope, meaning it can be accessed from anywhere within the same file. As shown in the image below.

The variable String greetingwhich is defined outside the main function (inside the global scope)can be accessed in the scope of the main() function using print(greeting), and the expected output is:

Reason being the variable greeting is defined globally and can be accessed within any function in the same file.

** 3.2 Local scope**
A local variable is declared inside a function or block. It can only be accessed within that specific function. Here is an illustration on the same.

The image above shows a sayHello() function with a variable String message defined inside it's scope.

When we try to access the variable inside the main() function using the print(message) we get an error

The error occurs because I am attempting to access a variable that is outside the scope of the main()function. But, when we call the function itself inside the main function the output is:

3.3 Lexical Scope
Dart uses lexical (or static) scope, which means that variable visibility is determined by where the variables and functions are written in the code, not by where they are called at runtime.
Each function can access variables defined in its enclosing scope.

The innerFunction() function can access the variables both in the scope of the main() and the outerFunction() String name and int agerespectively
This is because innerFunction() is lexically enclosed within main() and the outerFunction(), giving it access to all variables defined in it outer/enclosed scope.
Illustrating Dart’s lexical scoping rule, where a function can “see” variables in its surrounding scopes, but not vice versa.
expected output is:

3. Reflection.

Throughout this exploration of functions in Dart, several key lessons emerge that deepen both conceptual understanding and practical application in programming. Functions allow developers to write cleaner, modular code that is easy to maintain and debug. The main() Function is the Entry Point of Every Dart Program where execution begins. Moreover, functions in Dart are First-Class Objects meaning they can be stored in variables, passed as arguments, or even returned from other functions.
In essence, understanding how functions work from their structure, invocation, and scope to their role in code organization is fundamental to becoming a proficient developer.
Understanding these principles equips one with not only to write better code but also to design systems that are scalable, efficient, and easy to maintain.

Understanding Classes and Objects in Dart

Raphael Kihiro — Mon, 10 Nov 2025 07:02:48 +0000

1. Introduction

In object-oriented programming (OOP), classes serve as the fundamental building blocks for creating objects. A class acts as a blueprint that defines the properties (data) and behaviors(methods) that its objects will possess.
By using classes, Dart allows programmers to organize related variables and functions into a single logical unit. This approach supports core OOP principles: abstraction, encapsulation, inheritance, and polymorphism, making applications easier to manage and scale.

2. Structure and Syntax of a Class.

A class in Dart defines the structure of an object by grouping related data (variables) and behavior (methods) together.
Each class can include:
Instance variables – attributes or data that belong to each object.
Constructors – special functions that initialize new objects.
Methods – functions that define how an object behaves.

Below is an example of a simple Dart class definition:

The class Person defines a blueprint for creating Person objects.
It’s important to note that in the instance variables String? name, age, the ? symbol indicates that the string is nullable, meaning it can hold either a string value or null, and the constructor initializes the variables name,gender, and age whenever a new object is created.

As demonstrated in the image below inside the main function:

The showdata() method above prints out information about the person and the variable p1 creates a new instance of the Personclass with name set to “Raph,” genderto “male,” and age to 24.
When the code is executed, the expected output will be:

3. Creating and Using Objects in Dart

Once a class is defined, we can create objects from it.
An object is a specific, usable copy of a class that stores real data in memory.
You can think of a class as a blueprint, and each object as a real product built from that blueprint (class).To illustrate,follow the simple Car class.

The Car class serves as a blueprint for creating objects. As demonstrated below in the main() function:

Here, car1 and car2 are objects created from the Car class. You can create as many objects as needed, each with its own set of values for the properties defined in the class.

When the code is executed, the expected output is:

4. Constructors

A constructor is a special method in Dart that is automatically called when an object of a class is created.
Its main purpose is to initialize object properties and prepare the instance for use. Some of the existing constructors are:

4.1 Generative Constructors
A generative constructor is the most common form. It creates a new instance every time it is called. This type allows initializing instance variables either directly or through parameters.

Here, every time you call Student(name age ), a new Student obeject is created.

The expected output

4.2 Default Constructor

If no constructor is not explicitly defined, Dart automatically provides a default constructor that takes no arguments and does nothing other than create the object.

In the image above there are no constructors defined in the class Animal. But you create an object like so:

It is possible to create objects since dart provides a default constructor and if we call the method a.speak(). the expected output is;

4.3 Parameterized Constructor
A parameterized constructor allows you to pass data when creating an object.
This is the most common constructor type in Dart.

When you create an object or 2 then call the method.

The expected out-put is.

5. Methods in Dart

Methods are functions that belong to a class and define the behavior of its objects. They enable objects to perform actions, manipulate data, or communicate with other objects.

Dart supports two main categories of methods: instance methods and class (static) methods.

5.1 Instance Methods
An instance method operates on the data of a specific object.
To call an instance method, one must first create an instance of the class.

Here, displayInfo() is an instance method because it depends on the instance’s name and marks. Each Student object created has its own version data.(the instance method is called on instance variables in this case name and marks)

Output

5.2 Static (Class) Methods

A static method belongs to the class itself, not to any object. It is declared using the static keyword and can be called directly using the class name.

Static methods cannot access instance variables or instance methods directly — they can only work with static variables or parameters passed to them.

In this case static double squarethat pick up the double num as it's argument and when the method is called:

The expected output is ;

6. Extending a Class (Inheritance)

Sometimes, you’ll want one class to build upon another. That’s where inheritance comes in. Inheritance allows you to create a new class that reuses, extends, or modifies behavior of another class.

When you create a Dog object, it inherits the behavior of Animal.

You can override parent methods using @override.

7. Mixins

Inheritance isn’t the only way to share behavior Dart also supports mixins for more flexible code reuse. A mixin is a way to reuse code between classes without using inheritance.
Think of it as “copy-pasting” shared methods into multiple classes safely.

Important points to note about mixins.

You use them with the with keyword.
They don’t have constructors.
You can combine multiple mixins. Mixins are great for sharing behavior across unrelated classes.

8. Enums

Enums (short for enumerations) are a way to represent a fixed number of constant values.

Since Dart 2.17+, enums can contain methods, getters, and fields.

Enums are perfect for representing states, modes, or fixed categories.

9. Extension Methods

An extension method lets you add new behavior to existing types — without changing their source code.

10. Callable Objects

In Dart, you can make a class callable like a function by defining a call() method.

Callable objects are especially useful when you want function like behavior but still need the structure of a class (for example, in state management or data transformers).

Reflection

As I worked through these concepts, I realized that OOP in Dart is not just a set of rules—it’s a mindset. It encourages me to think more abstractly about problems, break them into manageable pieces, and design solutions that are both reusable and scalable.
OOP features has allows me as a developer to approach Dart projects with a clearer structure, a stronger understanding of code organization, and a deeper appreciation of how to model real-world scenarios efficient way. This journey has not only expanded my technical skill set but has also shaped my thought process toward writing cleaner, more intentional code.

LEARNING BASIC DART

Raphael Kihiro — Tue, 14 Oct 2025 06:41:09 +0000

Introduction to dart
Dart is a modern, object-oriented programming language developed by Google. It’s designed to be easy to learn, fast, and versatile, powering everything from mobile apps (using Flutter) to web and backend development.

From my experience, Dart’s syntax feels very familiar if you’ve worked with languages like JavaScript; it’s clean, intuitive, and beginner friendly. At the same time, it offers powerful features that make it an excellent choice for both beginners learning programming concepts and professionals building large-scale applications.

Why Learn Dart
From what I have gather in my first week learning the language:

Dart is a modern, object-oriented programming language developed by Google as an improvement over the popular JavaScript. It’s designed to be fast, powerful, and easy to learn, making it ideal for everything from web to backend and mobile app development.
Dart is a beast when it comes to building highly optimized backend systems especially in the hands of a skilled developer who has mastered its tools and features.
It also powers Flutter, one of the world’s most popular frameworks for cross-platform app development, allowing developers to build beautiful and efficient apps for Android, iOS, web, and desktop.
Learning Dart is a smart move for anyone interested in modern backend development. With Serverpod, Dart provides a clean, type-safe, and efficient way to build powerful server-side applications. It simplifies API creation, database integration, and communication — all while keeping your code fast, organized, and easy to maintain.

Basic Dart
As tradition dictates “Hello, World!” is the first program you write when learning a new programming language and here is how you go about it.

1. Hello World
Every app requires the top-level function, where execution starts. Functions that don't explicitly return a value have the void return type. To display text on the console, you can use the top-level print() function.

2. Variables in Dart
Variables store data that can be used, changed, and referenced throughout a program. In Dart, you declare variables using the var, final, or const keywords, depending on whether the value can change or not.

It is also important to note that variables are declared similarly to JavaScript following the Carmel-case naming convention.

a. var
the variable is used when the value can change. The image below demonstrates its use case.

b. final
final is a variable used when the value is set once and cannot be reassigned.

c. const
The const variable is almost similar to the final variable declaration in that they both can not be reassigned, although the value in a const must be known and fixed when the program is compiled, not during execution. It’s ideal for values that will never change and are shared across the program, improving performance and memory efficiency.

It is also important to note that variables in dart can be declared based on their data types to ensure type safety and clarity in your code. You can explicitly specify the type, such as int, double, String, bool, or List, to indicate the kind of data the variable will store, we will get into depth on this when we look at data types.

Data types in dart
Data types in Dart define the kind of values a variable can hold and how those values are used in a program. They ensure that data is stored and processed correctly. Common data types in Dart include numbers, strings, booleans, lists, maps, and dynamic types each serving a unique purpose in representing and managing different kinds of information within your code.

a. Numbers
Numbers in Dart are used to represent numeric values. They come in two main types; int for whole numbers and double for decimal values.

An integer can be converted from an integer to a double as illustrated below:

b. Strings
Strings store text data and are enclosed in either single or double quotes. They can also include variables using string interpolation (e.g., "Hello $name").

c. Booleans
Booleans represent logical values and can only be true or false.

d. List
Lists are ordered collections of items, similar to arrays in other languages. They allow you to store multiple values in a single variable and access them by index.

Lists in Dart are one of the most powerful and flexible data structures, allowing you to store and manipulate ordered collections of items. Dart lists are zero-indexed, meaning the first element starts at index 0, and you can access or update values using their index positions. You can add elements with methods like .add(), .addAll(), .insert(), or .insertAll(), and remove them using .remove(), .removeAt(), .removeLast(), or .clear(). Lists can also be searched using .contains() and .indexOf(), and organized using .sort(), .shuffle(), or .reversed. Dart makes it easy to loop through lists with for loops or .forEach(). Overall, Dart lists are incredibly versatile perfect for storing, modifying, and processing data efficiently in any program.

e. Maps
Maps store data as key-value pairs, allowing quick lookups by key.

You can add, modify, or remove entries using methods like .addAll(), .remove(), and .clear(). Maps also let you view all keys and values, check for specific entries, and efficiently manage structured data.

f. Sets
Sets in Dart are unordered collections of unique items, meaning no duplicates are allowed. They’re useful when you need to store distinct values, like IDs or names.

it is also important to note we can use the set constructor to change a list to a set

g. Dynamic
A dynamic variable can hold values of any type, and its type can change at runtime. While it gives flexibility, it also removes compile-time type safety so it’s best used only when the data type isn’t known in advance.

Operators in dart
Now that we have looked at data types in dart lets dig on some of the operators used in dart. Operators are special symbols used to perform operations on variables and values. They make it easier to write expressions for tasks like arithmetic, comparisons, and logic. Common types include arithmetic operators (+, -, *, /), comparison operators (==, !=, <, >), logical operators (&&, ||, !), and assignment operators (=, +=, -=).

Control flow

1. Loops in Dart

a. For Loop
Repeats a block of code a fixed number of times.

b. For-in Loop
Used to iterate through elements in a collection like a list.

c. While Loop
Executes while the condition is true (checked before the loop runs).

d. Do-While Loop
Runs the code at least once before checking the condition.

e. Break Statement
Stops the loop immediately when a condition is met.

f. Continue Statement
Skips the current iteration and moves to the next one.

*2. Conditional statements

a. if Statement
Used to test if a condition is true before executing a block of code.

b. else Statement
Runs when the if condition is not met. As illustrated by the image above

c. else if Statement
Used to check multiple conditions one after another.

d. if-case Statement
Used for pattern matching in Dart (checks data structure patterns).

e. switch Statement
Simplifies handling of multiple possible values for a variable.

Conclusion.

I’ve just started learning Dart, and I decided to document and publish my progress both to help upcoming developers exploring the language and to track my own growth. So far, it’s been an exciting journey. I’m already amazed by what it can do. I can’t wait to start building amazing projects with this tool, with the ultimate goal of using technology to solve real-world problems. Happy coding.

You can follow along with my Dart learning journey and projects on GitHub