DEV Community: sk00l

Understanding Shared Preferences in Flutter with Practical Examples

sk00l — Tue, 04 Jun 2024 12:05:29 +0000

What are Shared Preferences?

Shared Preferences in Flutter allow you to store key-value pairs of primitive data types. This storage method is perfect for saving small amounts of data, such as user settings or application preferences, that need to persist across sessions but do not require the overhead of a database.

Why Use Shared Preferences?

Using shared preferences in your Flutter app comes with several advantages:

Simplicity: Easy to implement and use.
No Database Needed: Avoids the complexity and resource usage of a full database.
Efficiency: Ideal for storing small amounts of data.
Persistence: Data remains available across app restarts.

Getting Started with Shared Preferences in Flutter

First, add the shared_preferences package to your pubspec.yaml file:

dependencies:
  flutter:
    sdk: flutter
  shared_preferences: ^2.0.6

Run flutter pub get to install the package.

Basic Usage

Import the Package
To use shared preferences, start by importing the package:

import 'package:shared_preferences/shared_preferences.dart';

Saving Data
Here's a simple function to save a string value:

Future<void> saveStringValue(String key, String value) async {
  final prefs = await SharedPreferences.getInstance();
  await prefs.setString(key, value);
}

Retrieving Data
To retrieve the stored string value, use:

Future<String?> getStringValue(String key) async {
  final prefs = await SharedPreferences.getInstance();
  return prefs.getString(key);
}

Here is a complete example of code for storing and retrieving data from Shared Preferences:

import 'package:flutter/material.dart';
import 'package:shared_preferences/shared_preferences.dart';

void main() {
  runApp(MyApp());
}

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Shared Preferences Demo',
      home: MyHomePage(),
    );
  }
}

class MyHomePage extends StatefulWidget {
  @override
  _MyHomePageState createState() => _MyHomePageState();
}

class _MyHomePageState extends State<MyHomePage> {
  String _key = "key";
  String _value = "value";

  @override
  void initState() {
    super.initState();
    _loadSavedValue();
  }

  // Function to load saved value from SharedPreferences
  void _loadSavedValue() async {
    SharedPreferences prefs = await SharedPreferences.getInstance();
    setState(() {
      _value = prefs.getString(_key) ?? ""; // Using ?? "" to handle null case
    });
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text("Shared Preferences Demo"),
      ),
      body: Center(
        child: Column(
          mainAxisAlignment: MainAxisAlignment.center,
          children: <Widget>[
            Text("Value: $_value"),
            TextField(
              decoration: InputDecoration(
                hintText: "Enter value",
              ),
              onChanged: (value) {
                setState(() {
                  _value = value;
                });
              },
            ),
            RaisedButton(
              child: Text("Save"),
              onPressed: () {
                _saveValue();
              },
            ),
          ],
        ),
      ),
    );
  }

  // Function to save value to SharedPreferences
  void _saveValue() async {
    SharedPreferences prefs = await SharedPreferences.getInstance();
    await prefs.setString(_key, _value);
  }
}

Unlocking the Power of Dart: A Comprehensive Guide to Function Parameters

sk00l — Mon, 15 Jan 2024 14:40:49 +0000

Introduction: Decoding Dart Function Parameters

Dart, a versatile programming language, offers a robust set of features, and understanding function parameters is key to unlocking its full potential. In this guide, we delve into the intricacies of Dart function parameters, accompanied by illustrative examples.

The Foundation: Exploring Dart Function Parameters
Function parameters serve as the building blocks of Dart applications. They enable developers to pass values into functions, enhancing code flexibility and reusability. Let's explore the core concepts.

Positional Parameters: Navigating the Basics
In Dart, positional parameters are the foundation of function input. These parameters rely on the order in which arguments are passed. Consider the following example:

void greetUser(String name, int age) {
  print("Hello, $name! You are $age years old.");
}

// Calling the function
greetUser("Alice", 30);

Here, "Alice" corresponds to the name parameter, and 30 aligns with the age parameter.

Default Parameters: Adding a Layer of Flexibility
Dart also supports default parameters, allowing developers to define a default value when an argument is not provided. This fosters adaptability within functions.

void orderCoffee(String coffeeType, [int sugarLevel = 1]) {
  print("A cup of $coffeeType with $sugarLevel sugar(s), please!");
}

// Calling the function
orderCoffee("Espresso"); // Defaults to 1 sugar
orderCoffee("Latte", 2); // Custom sugar level

In this example, the sugarLevel parameter defaults to 1 unless explicitly specified.

Named Parameters: Precision in Function Calls
Named parameters bring clarity to function calls by associating values with parameter names. This approach enhances code readability and reduces ambiguity.

void printDetails({String name, int age, String occupation}) {
  print("$name, aged $age, works as a $occupation.");
}

// Calling the function
printDetails(name: "Bob", age: 25, occupation: "Software Engineer");

Named parameters allow flexibility in the order of arguments, as long as they are explicitly named.

Flutter: A Deep Dive into Dart, Datatypes, Conditions and Operators

sk00l — Mon, 15 Jan 2024 14:29:45 +0000

In the dynamic landscape of app development, staying ahead is not just an advantage; it's a necessity. Flutter, powered by the versatile Dart language, emerges as a game-changer – a revolutionary open-source framework by Google. This comprehensive guide takes you on an exploration of Dart and Flutter, focusing on the essential elements of datatypes, conditional statements, and operators that empower developers to craft robust applications from a single codebase.

Unraveling Dart: The Backbone of Flutter

Dart, the language that fuels Flutter, is at the core of its success. As a statically typed language, Dart ensures the reliability and efficiency of Flutter applications. Let's delve into the key aspects of Dart that every Flutter developer should master.

1. Variables and Dynamic Typing
Dart introduces a flexible approach to variables, allowing developers to leverage dynamic typing. This means you can declare variables without explicitly specifying their datatype, enhancing code flexibility while maintaining the benefits of static typing.

2. Functions in Dart
Functions are the building blocks of any programming language, and Dart is no exception. Learn how Dart's functions offer modularity and reusability, facilitating the development of scalable and maintainable Flutter applications.

3. Object-Oriented Paradigm
Dart embraces the object-oriented programming paradigm, providing developers with a powerful and intuitive way to structure their code. Dive into Dart's classes, objects, and inheritance to harness the full potential of Flutter development.

Understanding Datatypes in Dart

Flutter inherits Dart's robust datatype system, which plays a pivotal role in defining variables. Let's explore the fundamental datatypes that form the bedrock of Dart programming.

1. Integers (int) and Doubles (double)
Dart, like Flutter, employs integers for whole numbers and doubles for decimal precision. Mastering these datatypes is essential for handling numeric data efficiently in your Dart code.

// Integers and Doubles
int integerValue = 42;
double doubleValue = 3.14;

2. Strings (String) and Booleans (bool)
Strings and booleans are indispensable in any programming language. In Dart, these datatypes find their place in handling textual information and logical decision-making, respectively.

// Strings and Booleans
String text = "Dart is amazing!";
bool isFlutterAwesome = true;

3. Lists (list) and Maps (Map)
In Dart, lists provide ordered collections, while maps offer key-value pairs. Combining them allows developers to create versatile data structures for efficient information management. In Dart, arrays are List objects, so we call them lists. In general, a map is an object that associates keys and values. Both keys and values can be any type of object.

//Lists
var list = [1, 2, 3];

//Maps
var gifts = {
  // Key:    Value
  'first': 'partridge',
  'second': 'turtledoves',
  'fifth': 'golden rings'
};

Mastering Conditional Statements in Dart

Conditional statements in Dart provide developers with the tools to make decisions within their code. Let's delve into the conditional constructs Dart offers for efficient decision-making in your Flutter applications.

1. If Statements and Switch Statements
Learn how Dart's if statements and switch statements empower you to create logical conditions, guiding the flow of your application intelligently. These constructs are fundamental for decision-making in Dart programming.

// If statement
int number = 10;
if (number > 0) {
  print("Number is positive");
} else {
  print("Number is non-positive");
}

// Switch statement
String fruit = "apple";
switch (fruit) {
  case "apple":
    print("It's an apple");
    break;
  case "banana":
    print("It's a banana");
    break;
  default:
    print("Unknown fruit");
    break;
}

Navigating Dart's Operators

Operators in Dart enable developers to perform operations on variables and values. Let's explore the diverse set of operators that Dart puts at your disposal for numeric and logical manipulations.

1. Arithmetic Operators, Relational Operators, and Logical Operators
From basic arithmetic to complex boolean logic, Dart's operators are essential for shaping your Flutter application. Gain proficiency in arithmetic, relational, and logical operators to wield Dart effectively.

// Arithmetic Operators
int a = 10;
int b = 5;
print("Sum: ${a + b}, Difference: ${a - b}, Product: ${a * b}, Quotient: ${a / b}");

// Relational Operators
bool isEqual = (a == b);
bool isNotEqual = (a != b);

// Logical Operators
bool isTrue = true;
bool isFalse = false;
bool result = isTrue && isFalse; // Logical AND

Conclusion

In this exploration of Dart and Flutter, we've unveiled the language's core features, datatypes, conditional statements, and operators – the elements that empower developers to create exceptional applications. As you embark on your Dart and Flutter development journey, remember that mastering these foundational components sets the stage for success in the dynamic realm of app creation. Happy coding!