mirror of
https://github.com/Fechin/reference.git
synced 2026-11-20 21:23:11 +03:00
646 lines
12 KiB
Markdown
646 lines
12 KiB
Markdown
---
|
||
title: Dart
|
||
date: 2021-11-04 10:12:25
|
||
background: bg-[#58aee9]
|
||
tags:
|
||
- dart
|
||
- flutter
|
||
categories:
|
||
- Programming
|
||
intro: |
|
||
A Dart cheat sheet with the most important concepts, functions, methods, and more. A complete quick reference for beginners.
|
||
plugins:
|
||
- copyCode
|
||
---
|
||
|
||
|
||
|
||
|
||
Getting Started {.cols-2}
|
||
------------
|
||
|
||
### hello.dart
|
||
```dart
|
||
// top-level function where app execution starts
|
||
void main(){
|
||
print("Hello World!"); // Print to console
|
||
}
|
||
```
|
||
Every app has a main() function
|
||
|
||
|
||
### Variables
|
||
|
||
```dart
|
||
int x = 2; // explicitly typed
|
||
var p = 5; // type inferred - Generic var with type inference
|
||
|
||
dynamic z = 8; // variable can take on any type
|
||
z = "cool"; // cool
|
||
|
||
// if you never intend to change a variable use final or const. Something like this:
|
||
|
||
final email = "temid@gmail.com"; // Same as var but cannot be reassigned
|
||
final String email = "temid@gmail.com"; // you can't change the value
|
||
|
||
const qty = 5; // Compile-time constant
|
||
```
|
||
|
||
|
||
### Datatypes
|
||
|
||
```dart
|
||
|
||
int age = 20; // integers, range -2^63 to 2^63 - 1
|
||
double height = 1.85; // floating-point numbers
|
||
|
||
// You can also declare a variable as a num
|
||
num x = 1; // x can have both int and double values
|
||
num += 2.5;
|
||
print(num); //Print: 3.5
|
||
|
||
String name = "Nicola";
|
||
|
||
bool isFavourite = true;
|
||
bool isLoaded = false;
|
||
```
|
||
|
||
|
||
### String interpolation
|
||
|
||
```dart
|
||
// can use single or double qoutes for String type
|
||
var firstName = 'Nicola';
|
||
var lastName = "Tesla";
|
||
|
||
//can embed variables in string with $
|
||
String fullName = "$firstName $lastName";
|
||
|
||
// concatenate with +
|
||
var name = "Albert " + "Einstein";
|
||
|
||
String upperCase = '${firstName.toUpperCase()}';
|
||
print(upperCase); //Print: NICOLA
|
||
```
|
||
|
||
### Comments
|
||
```dart
|
||
// This is a normal, one-line comment.
|
||
|
||
/// This is a documentation comment, used to document libraries,
|
||
/// classes, and their members. Tools like IDEs and dartdoc treat
|
||
/// doc comments specially.
|
||
|
||
/* Comments like these are also supported. */
|
||
```
|
||
|
||
### Imports
|
||
```dart
|
||
// Importing core libraries
|
||
import 'dart:math';
|
||
|
||
// Importing libraries from external packages
|
||
import 'package:test/test.dart';
|
||
|
||
// Importing files
|
||
import 'path/to/my_other_file.dart';
|
||
```
|
||
|
||
|
||
Operators {.cols-2}
|
||
------------
|
||
|
||
### Arithmatic Operators
|
||
```dart
|
||
print(2 + 3); //Print: 5
|
||
print(2 - 3); //Print: -1
|
||
print(2 * 3); //Print: 6
|
||
print(5 / 2); //Print: 2.5 - Result is a double
|
||
print(5 ~/ 2); //Print: 2 - Result is an int
|
||
print(5 % 2); //Print: 1 - Remainder
|
||
|
||
int a = 1, b;
|
||
// Increment
|
||
b = ++a; // preIncrement - Increment a before b gets its value.
|
||
b = a++; // postIncrement - Increment a AFTER b gets its value.
|
||
|
||
//Decrement
|
||
b = --a; // predecrement - Decrement a before b gets its value.
|
||
b = a--; // postdecrement - Decrement a AFTER b gets its value.
|
||
```
|
||
|
||
|
||
### Equality and relational operators
|
||
```dart
|
||
print(2 == 2); //Print: true - Equal
|
||
print(2 != 3); //Print: true - Not Equal
|
||
print(3 > 2); //Print: true - Grater than
|
||
print(2 < 3); //Print: true - Less than
|
||
print(3 >= 3); //Print: true - Greater than or equal to
|
||
print(2 <= 3); //Print: true - Less than or equal to
|
||
```
|
||
|
||
|
||
### Logical operators
|
||
```dart
|
||
// !expr inverts the expression (changes false to true, and vice versa)
|
||
// || logical OR
|
||
// && logical AND
|
||
bool isOutOfStock = false;
|
||
int quantity = 3;
|
||
if (!isOutOfStock && (quantity == 2 || quantity == 3)) {
|
||
// ...Order the product...
|
||
}
|
||
```
|
||
|
||
|
||
|
||
|
||
Control Flows : Conditionals {.cols-2}
|
||
------------
|
||
|
||
|
||
### if and else if
|
||
```dart
|
||
if(age < 18){
|
||
print("Teen");
|
||
} else if( age > 18 && age <60){
|
||
print("Adult");
|
||
} else {
|
||
print("Old");
|
||
}
|
||
```
|
||
|
||
|
||
### switch case
|
||
```dart
|
||
enum Pet {dog, cat}
|
||
Pet myPet = Pet.dog;
|
||
switch(myPet){
|
||
case Pet.dog:
|
||
print('My Pet is Dog.');
|
||
break;
|
||
case Pet.cat:
|
||
print('My Pet is Cat.');
|
||
break;
|
||
default:
|
||
print('I don\'t have a Pet');
|
||
}
|
||
// Prints: My Pet is Dog.
|
||
```
|
||
|
||
|
||
|
||
|
||
Control Flows : Loops
|
||
------------
|
||
|
||
|
||
### while loop
|
||
```dart
|
||
while (!dreamsAchieved) {
|
||
workHard();
|
||
}
|
||
```
|
||
while loop check condition before iteration of the loop
|
||
|
||
### do-while loop
|
||
```dart
|
||
do {
|
||
workHard();
|
||
} while (!dreamsAchieved);
|
||
```
|
||
do-while loop verifies the condition after the execution of the statements inside the loop
|
||
|
||
### for loop
|
||
```dart
|
||
for(int i=0; i< 10; i++){
|
||
print(i);
|
||
}
|
||
|
||
var numbers = [1,2,3];
|
||
// for-in loop for lists
|
||
for(var number in numbers){
|
||
print(number);
|
||
}
|
||
```
|
||
|
||
|
||
|
||
Collections {.cols-2}
|
||
------------
|
||
|
||
### Lists
|
||
|
||
```dart
|
||
// ordered group of objects
|
||
var list = [1, 2, 3];
|
||
|
||
print(list.length); //Print: 3
|
||
print(list[1]); //Print: 2
|
||
|
||
// other ways of list declaration and initializations
|
||
|
||
List<String> cities = <String>["New York", "Mumbai", "Tokyo"];
|
||
|
||
// To create a list that’s a compile-time constant
|
||
const constantCities = const ["New York", "Mumbai", "Tokyo"];
|
||
```
|
||
|
||
|
||
### Sets
|
||
|
||
```dart
|
||
// A set in Dart is an unordered collection of unique items.
|
||
var halogens = {'fluorine', 'chlorine', 'bromine', 'iodine', 'astatine'};
|
||
|
||
// to create an empty set
|
||
var names = <String>{};
|
||
Set<String> names = {}; // This works, too.
|
||
//var names = {}; // Creates a map, not a set.
|
||
```
|
||
|
||
|
||
### Maps
|
||
|
||
```dart
|
||
// a map is an object that associates keys and values
|
||
var person = Map<String, String>();
|
||
// To initialize the map, do this:
|
||
person['firstName'] = 'Nicola';
|
||
person['lastName'] = 'Tesla';
|
||
|
||
print(person); //Print: {firstName: Nicola, lastName: Tesla}
|
||
print(person['lastName']); //Print: Tesla
|
||
|
||
|
||
var nobleGases = {
|
||
// Key: Value
|
||
2: 'helium',
|
||
10: 'neon',
|
||
18: 'argon',
|
||
};
|
||
```
|
||
|
||
|
||
|
||
Functions {.cols-2}
|
||
------------
|
||
|
||
### Functions
|
||
```dart
|
||
// functions in dart are objects and have a type
|
||
int add(int a, int b){
|
||
return a+b;
|
||
}
|
||
|
||
// functions can be assigned to variables
|
||
int sum = add(2,3); // returns: 5
|
||
|
||
// can be passed as arguments to other functions
|
||
int totalSum = add(2, add(2,3)); // returns : 7
|
||
```
|
||
|
||
|
||
### Arrow Syntax (=>)
|
||
```dart
|
||
// functions that contain just one expression, you can use a shorthand syntax
|
||
bool isFav(Product product) => favProductsList.contains(product);
|
||
```
|
||
|
||
### Anonymous (lambda) functions
|
||
```dart
|
||
// small one line functions that dont have name
|
||
int add(a,b) => a+b;
|
||
|
||
// lambda functions mostly passed as parameter to other functions
|
||
const list = ['apples', 'bananas', 'oranges'];
|
||
list.forEach(
|
||
(item) => print('${list.indexOf(item)}: $item'));
|
||
//Prints: 0: apples 1: bananas 2: oranges
|
||
```
|
||
|
||
Classes and Objects
|
||
----------
|
||
|
||
### Class
|
||
```dart
|
||
class Cat {
|
||
String name;
|
||
|
||
// method
|
||
void voice(){
|
||
print("Meow");
|
||
}
|
||
}
|
||
```
|
||
|
||
|
||
### Object
|
||
```dart
|
||
// instance of a class
|
||
// below myCat is Object of class Cat
|
||
|
||
void main(){
|
||
Cat myCat = Cat();
|
||
myCat.name = "Kitty";
|
||
myCat.voice(); // Prints: Meow
|
||
}
|
||
```
|
||
|
||
|
||
### Constructors
|
||
```dart
|
||
class Cat {
|
||
String name;
|
||
Cat(this.name);
|
||
}
|
||
void main(){
|
||
Cat myCat = Cat("Kitty");
|
||
print(myCat.name); // Prints: Kitty
|
||
}
|
||
```
|
||
|
||
|
||
### Abstract Classes
|
||
```dart
|
||
// abstract class—a class that can’t be instantiated
|
||
// This class is declared abstract and thus can't be instantiated.
|
||
abstract class AbstractContainer {
|
||
// Define constructors, fields, methods...
|
||
|
||
void updateChildren(); // Abstract method.
|
||
}
|
||
```
|
||
|
||
|
||
### Getters Setters
|
||
```dart
|
||
// provide read and write access to an object’s properties
|
||
class Cat {
|
||
String name;
|
||
|
||
// getter
|
||
String get catName {
|
||
return name;
|
||
}
|
||
|
||
// setter
|
||
void set catName(String name){
|
||
this.name = name;
|
||
}
|
||
}
|
||
```
|
||
|
||
|
||
Implicit interfaces {.cols-2}
|
||
------------
|
||
|
||
### A basic interface
|
||
```dart
|
||
// A person. The implicit interface contains greet().
|
||
class Person {
|
||
// In the interface, but visible only in this library.
|
||
final String _name;
|
||
|
||
// Not in the interface, since this is a constructor.
|
||
Person(this._name);
|
||
|
||
// In the interface.
|
||
String greet(String who) => 'Hello, $who. I am $_name.';
|
||
}
|
||
|
||
// An implementation of the Person interface.
|
||
class Impostor implements Person {
|
||
String get _name => '';
|
||
|
||
String greet(String who) => 'Hi $who. Do you know who I am?';
|
||
}
|
||
|
||
String greetBob(Person person) => person.greet('Bob');
|
||
|
||
void main() {
|
||
print(greetBob(Person('Kathy'))); // Hello, Bob. I am Kathy.
|
||
print(greetBob(Impostor())); // Hi Bob. Do you know who I am?
|
||
}
|
||
```
|
||
|
||
### Extending a class
|
||
```dart
|
||
class Phone {
|
||
|
||
void use(){
|
||
_call();
|
||
_sendMessage();
|
||
}
|
||
}
|
||
// Use extends to create a subclass
|
||
class SmartPhone extends Phone {
|
||
void use(){
|
||
// use super to refer to the superclass
|
||
super.use();
|
||
_takePhotos();
|
||
_playGames();
|
||
}
|
||
}
|
||
```
|
||
|
||
Exceptions
|
||
------------
|
||
|
||
### Throw
|
||
```dart
|
||
// throws or raises and exception
|
||
throw IntegerDivisionByZeroException();
|
||
|
||
// You can also throw arbitrary objects
|
||
throw "Product out of stock!";
|
||
```
|
||
|
||
### Catch
|
||
```dart
|
||
|
||
try {
|
||
int c = 3/0;
|
||
print(c);
|
||
} on IntegerDivisionByZeroException {
|
||
// A specific exception
|
||
print('Can not divide integer by 0.')
|
||
} on Exception catch (e) {
|
||
// Anything else that is an exception
|
||
print('Unknown exception: $e');
|
||
} catch (e) {
|
||
// No specified type, handles all
|
||
print('Something really unknown: $e');
|
||
}
|
||
|
||
```
|
||
### Finally
|
||
```dart
|
||
// To ensure that some code runs whether or not an exception is thrown
|
||
try {
|
||
cookFood();
|
||
} catch (e) {
|
||
print('Error: $e'); // Handle the exception first.
|
||
} finally {
|
||
cleanKitchen(); // Then clean up.
|
||
}
|
||
```
|
||
|
||
|
||
Futures
|
||
------------
|
||
### Async Await
|
||
```dart
|
||
// functions which are asynchronous: they return after setting up a possibly time-consuming operation
|
||
// The async and await keywords support asynchronous programming
|
||
|
||
Future<String> login() {
|
||
String userName="Temidjoy";
|
||
return
|
||
Future.delayed(
|
||
Duration(seconds: 4), () => userName);
|
||
}
|
||
|
||
// Asynchronous
|
||
main() async {
|
||
print('Authenticating please wait...');
|
||
print(await login());
|
||
}
|
||
```
|
||
|
||
Extensions {.cols-2}
|
||
----------
|
||
|
||
### Why use extensions? {.row-span-2}
|
||
```dart
|
||
// Extensions allow you to add methods to existing
|
||
// classes without modifying them.
|
||
|
||
// Instead of defining a util class.
|
||
class StringUtil {
|
||
static bool isValidEmail(String str) {
|
||
final emailRegExp = RegExp(r"^[a-zA-Z0-9.]+@[a-zA-Z0-9]+\.[a-zA-Z]+");
|
||
return emailRegExp.hasMatch(str);
|
||
}
|
||
}
|
||
|
||
print(StringUtil.isValidEmail('someString')); //Print: false
|
||
|
||
// We can define an extension which will be applied
|
||
// on a certain type.
|
||
|
||
extension StringExtensions on String {
|
||
bool get isValidEmail {
|
||
final emailRegExp = RegExp(r"^[a-zA-Z0-9.]+@[a-zA-Z0-9]+\.[a-zA-Z]+");
|
||
return emailRegExp.hasMatch(this);
|
||
}
|
||
}
|
||
|
||
print('test@example.com'.isValidEmail); //Print: true
|
||
print('SomeString'.isValidEmail); //Print: false
|
||
|
||
```
|
||
### Generic Extensions
|
||
```dart
|
||
// allows you to apply the same logic to a range of types.
|
||
extension NumGenericExtensions<T extends num> on T {
|
||
T addTwo() => this + 2 as T;
|
||
}
|
||
|
||
print(7.addTwo()); // Print: 9
|
||
```
|
||
|
||
### Dart Extensions in Flutter
|
||
```dart
|
||
extension ContextExtension on BuildContext {
|
||
double get screenHeight => MediaQuery.of(this).size.height;
|
||
double get screenWidth => MediaQuery.of(this).size.width;
|
||
}
|
||
|
||
// usage
|
||
@override
|
||
Widget build(BuildContext context) => MaterialApp(
|
||
home: Scaffold(
|
||
body: Container(
|
||
width: context.screenWidth * 0.5,
|
||
height: context.screenHeight * 0.3,
|
||
color: Colors.blue,
|
||
child: Text('Hello World!'),
|
||
),
|
||
),
|
||
);
|
||
```
|
||
|
||
|
||
Miscellaneous {.cols-2}
|
||
------------
|
||
|
||
### Null and Null aware
|
||
|
||
```dart
|
||
int x; // The initial value of any object is null
|
||
|
||
// ?? null aware operator
|
||
|
||
x ??=6; // ??= assignment operator, which assigns a value of a variable only if that variable is currently null
|
||
print(x); //Print: 6
|
||
|
||
x ??=3;
|
||
print(x); // Print: 6 - result is still 6
|
||
|
||
print(null ?? 10); // Prints: 10. Display the value on the left if it's not null else return the value on the right
|
||
```
|
||
|
||
|
||
|
||
### Ternary Operator
|
||
```dart
|
||
// condition ? exprIfTrue : exprIfFalse
|
||
bool isAvailable;
|
||
|
||
isAvailable ? orderproduct() : addToFavourite();
|
||
```
|
||
|
||
|
||
### Spread Operator (...)
|
||
|
||
```dart
|
||
// to insert multiple values into a collection.
|
||
var list = [1, 2, 3];
|
||
var list2 = [0, ...list];
|
||
|
||
print(list2.length); //Print: 4
|
||
```
|
||
|
||
### Cascade notation (..)
|
||
|
||
```dart
|
||
// allows you to make a sequence of operations on the same object
|
||
|
||
// rather than doing this
|
||
var user = User();
|
||
user.name = "Nicola";
|
||
user.email = "nicola@g.c";
|
||
user.age = 24;
|
||
|
||
// you can do this
|
||
var user = User()
|
||
..name = "Nicola"
|
||
..email = "nicola@g.c"
|
||
..age = 24;
|
||
```
|
||
|
||
### Conditional Property Access
|
||
```dart
|
||
userObject?.userName
|
||
|
||
//The code snippet above is equivalent to following:
|
||
(userObject != null) ? userObject.userName : null
|
||
|
||
//You can chain multiple uses of ?. together in a single expression
|
||
userObject?.userName?.toString()
|
||
|
||
// The preceeding code returns null and never calls toString() if either userObject or userObject.userName is null
|
||
```
|