In this article, I'll teach you how to create Dart package to your Flutter apps so that you may enhance and reuse your code.
Why is this significant?
When working with large apps, it can be difficult to keep folders structured and to minimize interdependencies between documents and different areas of the project.
Dart packages address this issue by making apps more flexible and dependencies more apparent.
So, if you have a single massive application or numerous apps that need to share certain function, extracting reusable code in packages is the way to go.
To create cross-platform apps, we employ the Dart programming language in Flutter. Dart packages are similar to the libraries you could install for Node.js applications using npm or yarn. These packages are created by Flutter developers for Flutter developers.
We'll teach you how to create Dart packages and distribute them with other Flutter developers all across the world in this tutorial.
Well cover the following:
What exactly is a Dart package?
Package types for darts
Putting together a Flutter/Dart bundle
Flutter package testing
Publication and distribution of your Flutter package
What exactly is a Dart package?
Dart packages allow us to solve difficulties and develop solutions without having to write the code from start.
Assume we're developing a Flutter app and realise we need to upload a photo from our local storage and show it in the app. That would be laborious and time-consuming if we did it ourselves.
Most likely, someone somewhere has already created a Dart package for Flutter to handle the image selecting and display functions for us. All that remains is to install the package and then use its methods and classes to search and show pictures. This gives us more time to focus on the app's fundamental business logic.
Package types for darts
Dart packages are divided into two types: standard Dart packages and plugin packages.
Dart packages are Dart-based general-purpose packages. They are not restricted to any native platforms, such as Android or iOS. These are Flutter-specific packages that can only be used on the Flutter framework.
Plugin packages are platform-specific and contain Dart-coded APIs. These packages may be created in Kotlin or Java for Android, Swift or Objective-C for iOS, web, macOS, Windows, or Linux.
In this article, we'll show you how to make a Dart package.
Putting together a Flutter/Dart bundle:
Run the following command to build a Flutter package:
flutter package flutter pkg create —template=flutter pkg
To create a Flutter project or package, use the create subcommand. It will produce a Flutter package in this situation.
The —template=package option instructs it to generate a Flutter package.
The flutter pkg folder is where the Flutter package will be stored. You may call it whatever you like.
Let's take a look at some of the files and folders we created to see what they accomplish.
pubspec.yaml includes information about a Flutter package as well as project dependencies. It also allows us to select the assets we want to include in our Flutter project, such as photos, fonts, and so on. When we publish our code to a repository, gitignore informs Git which files in our Flutter project to ignore.
README.md is a Markdown file that includes general information about the project. This file, among other things, details how to install, operate, and contribute to the project.
CHANGELOG.md is where we record changes to the project. This page is written in Markdown as well.
Flutter package testing:
We'll need to put our product through its paces to determine if it works. To accomplish so, we must include a Flutter project in our project:
Example of flutter creation
In our flutter pkg project, an example folder will be generated.
Then, in the sample Flutter project, we must install our flutter pkg. We will refer to the route locally because the package has not yet been uploaded on pub.dev.
Now we can publish it to pub.dev so that other developers may utilise it.
Publication and distribution of your Flutter package
Now that we know our Dart package works, we can publish it to pub.dev so that other developers can utilise it.
Let's add a licence to the LICENSE file before we publish our package:
2022 Krishna Dhaduk Copyright (c)
Permission is allowed to use this programme as you see appropriate.
It's finally time to release our package:
flutter packages pub release
If you are not yet permitted on pub.dev, it will request authorisation at the bottom.
Then, using Ctrl + Click, navigate to the link in the terminal above. Finally, you will be asked to allow access using your chosen Gmail account.
Conclusion:
Dart packages are an excellent method to scale up projects, whether you work for yourself or for a large corporation.
This course covers a lot of ground. We began by discussing Dart packages, what they are, and how they are meant to share code with other developers.
They help to make code more modular, reusable, and with well-defined dependencies.
Following that, we learnt how to test our Flutter package locally before publishing it to pub.dev.
They also make it simpler to divide code ownership among contributors.
You should think about employing them whether you're working on a single major app or a collection of smaller applications.
There's a reason we have a complete package ecosystem on pub.dev, after all.
Types of Constructors in Dart
What is the constructor and why we use it?
The term "constructors" is one that most of us are acquainted with. They enable us to generate many instances of our classes. We may define the parameters the class should rely on when instantiating it and mask the underlying initialization mechanism.
We can have many constructors for various use cases or rely on the default one.
Constructors fulfil a similar role in Dart, although there are various variants that are not seen in most programming languages. This article will go over the many function Object() { [native code] } use cases and examples in Dart.
Constructors in Dart:
Constructors have the same name as the class and no return type.
name of class ( [ parameters ] )
/ Body of the Constructor
In the preceding syntax:
The name of the class whose function Object(){[native code]} is being constructed is class name.
The constructor's arguments are optional characteristics that can and cannot be defined. There are no parameters provided in the default function Object() { [native code] }.
Constructor body is the constructor's body, which is performed when the function Object() { native code]} is invoked, i.e., when an object is constructed.
There is no return type for constructors.
Dart has three types of constructors:
1. Parameterized Constructor:
2. Default Constructor:
3. Named Constructor:
1) Default Constructor or no-arg Constructor:
Default constructors are constructors that do not contain any parameters. As a result, if a function Object() { [native code] } has no parameters, it is a kind of default function Object() { [native code] }.
In Dart, for example, create a default function Object() {[native code] }.
Syntax:
class ClassName {
ClassName() {
// constructor body
}
}
2) Parameterized Constructor:
In Dart, you can also define a function Object() { [native code] } with arguments. These arguments will determine which function Object() { [native code] } is called and which is not. Parameterized constructors are constructors that accept parameters.
Syntax:
class ClassName {
ClassName(parameter_list)
// constructor body
}
3) Named Constructor:
Because you can't declare several constructors with the same name, this form of function Object() { [native code] } solves the problem. They enable the user to create several constructors, each with a unique name.
Syntax:
className.constructor_name(param_list)
Conclusion
Each of the constructors we reviewed serves a distinct function and has a different use case. It is your responsibility to comprehend and know when to utilize each one. Hopefully, this post has provided you with the required information.
You may learn more about Dart constructors by visiting Dart's language tour.