برنامه نویسی 1240 بازدید

در این مقاله به بررسی شیوه طراحی و ساخت یک اپلیکیشن ماشین حساب ساده با استفاده از Dart و Flutter می‌پردازیم. زبان برنامه‌نویسی دارت و SDK فلاتر ویژگی‌هایی عالی در اختیار توسعه‌دهندگان قرار می‌دهند و یک کیت ابزار کامل برای امتحان کردن سریع ایده‌های جدید و ساخت اپلیکیشن‌های با عملکرد بالا محسوب می‌شوند. با ما تا انتهای این راهنمای ساخت اپلیکیشن ماشین حساب با فلاتر همراه باشید.

اپلیکیشن ساده ماشین حساب ما شامل یک رابط کاربری ساده، چند عملیات و تابع ساده و یک خروجی است که نتیجه را نمایش می‌دهد. بنابراین یک اپلیکیشن آغازین یا قالب عالی برای طراحی و ساخت هر گونه اپلیکیشن دیگر محسوب می‌شود.

کد منبع این پروژه را می‌توانید در این ریپوی گیت‌هاب (+) ملاحظه کنید.

شروع توسعه اپلیکیشن ماشین حساب با فلاتر

پروژه این اپلیکیشن با استفاده از دستور flutter create و بدون نیاز به هیچ گونه پکیج یا وابستگی اضافی ایجاد می‌شود، زیرا همه قابلیت‌هایی که می‌خواهیم با استفاده از دارت و فلاتر خالی به روشی ساده و پایدار قابل پیاده‌سازی هستند.

بهره‌گیری از قابلیت‌های داخلی یک زبان و SDK باعث می‌شود که معماری یک اپلیکیشن تا حد امکان منعطف و کارآمد بماند و در نتیجه عملکرد پروژه افزایش یابد، فایل‌های کامپایل شده اپلیکیشن سریع‌تر باشند و بدهی فنی کمتری ایجاد شود.

برای ساخت این پروژه یا ایجاد هر نوع پروژه مشابه تنها دو مورد زیر لازم هستند:

  • Dart
  • Flutter SDK

نقطه ورود اپلیکیشن

نقطه ورود اپلیکیشن برای این پروژه استاندارد فلاتر به صورت lib/main.dart است:

import 'package:flutter/material.dart';
import 'package:flutter/services.dart';
import 'package:flutter_calculator_demo/calculator.dart';

void main() async {
  await SystemChrome.setPreferredOrientations([DeviceOrientation.portraitUp]);
  runApp(CalculatorApp());
}

class CalculatorApp extends StatelessWidget {

  @override
  Widget build(BuildContext context) {

    return MaterialApp(
      theme: ThemeData(primarySwatch: Colors.teal),
      home: Calculator(),
    );
  }
}

تابع main صفحه دستگاه را در حالت عمودی قفل می‌کند و سپس کلاس اصلی اپلیکیشن یعنی CalculatorApp را اجرا می‌کند که به نوبه خود یک MaterialApp می‌سازد که صفحه اصلی‌اش روی یک وهله از Calculator تنظیم شده است. در بخش بعدی به بررسی این کلاس می‌پردازیم.

کلاس Calculator

UX اصلی ماشین حساب در lib/calculator.dart تعریف شده است:

import 'package:flutter/material.dart';
import 'package:flutter_calculator_demo/display.dart';
import 'package:flutter_calculator_demo/key-controller.dart';
import 'package:flutter_calculator_demo/key-pad.dart';
import 'package:flutter_calculator_demo/processor.dart';

class Calculator extends StatefulWidget {

  Calculator({ Key key }) : super(key: key);

  @override
  _CalculatorState createState() => _CalculatorState();
}

class _CalculatorState extends State<Calculator> {

  String _output;

  @override
  void initState() {
    
    KeyController.listen((event) => Processor.process(event));
    Processor.listen((data) => setState(() { _output = data; }));
    Processor.refresh();
    super.initState();
  }

  @override
  void dispose() {

    KeyController.dispose();
    Processor.dispose();
    super.dispose();
  }

  @override
  Widget build(BuildContext context) {

    Size screen = MediaQuery.of(context).size;

    double buttonSize = screen.width / 4;
    double displayHeight = screen.height - (buttonSize * 5) - (buttonSize);
  
    return Scaffold(
      backgroundColor: Color.fromARGB(196, 32, 64, 96),
      body: Column(
        
        mainAxisAlignment: MainAxisAlignment.center,
        children: <Widget>[

          Display(value: _output, height: displayHeight),
          KeyPad()
        ]
      ),
    );
  }
}

کلاس Calculator یک «ویجت حالت دار» (StatefulWidget) است که برای UX کلی اپلیکیشن ساخته شده است و پردازش کلیدها را به کلاس Processor ارسال کرده و داده‌ها را برای نمایش دریافت می‌کند. این کار به وسیله بهره‌گیری از استریم‌ها صورت می‌پذیرد که به جای تلاش برای پیاده‌سازی برخی نسخه‌های مدیریت حالت سنگین، پیام‌هایی را به صورت مستقیم بین کامپوننت‌ها رد و بدل می‌کند.

یک فراخوانی منفرد به setState وجود دارد که خروجی نمایشی را به‌روزرسانی می‌کند و هر چیز دیگر به وسیله ارسال استریم داده‌های رویداد ناهمگام بین کلاس‌های KeyPad ،KeyController ،Calculator و Processor اتفاق می‌افتد. این وضعیت تضمین می‌کند که گردش مورد نظر اطلاعات وجود دارد و به جلوگیری از شرایط رقابت و دیگر مشکلاتی که دیباگ کردنشان دشوار است کمک می‌کند.

در متد build، اندازه دکمه با تقسیم کردن عرض صفحه بر تعداد دکمه‌ها و ارتفاع Display به وسیله کم کردن ارتفاع ستون پنج دکمه‌ای (ارتفاع صفحه‌کلید عددی) از ارتفاع صفحه دستگاه به دست می‌آید.

ویجت Display

فایل بعدی که مورد بررسی قرار می‌دهیم نمایشگر ماشین حساب در فایل lib/display.dart است:

import 'package:flutter/material.dart';

class Display extends StatelessWidget {

	Display({ Key key, this.value, this.height }) : super(key: key);

	final String value;
	final double height;

	String get _output => value.toString();
	double get _margin => (height / 10);

	final LinearGradient _gradient = const LinearGradient(colors: [ Colors.black26, Colors.black45 ]);

	@override
	Widget build(BuildContext context) {
		
		TextStyle style = Theme.of(context).textTheme.display2
			.copyWith(color: Colors.white, fontWeight: FontWeight.w200);

		return Container(
			padding: EdgeInsets.only(top: _margin, bottom: _margin),
			constraints: BoxConstraints.expand(height: height),
			child: Container(
				padding: EdgeInsets.fromLTRB(32, 32, 32, 32),
				constraints: BoxConstraints.expand(height: height - (_margin)),
				decoration: BoxDecoration(gradient: _gradient),
				child: Text(_output, style: style, textAlign: TextAlign.right, )
			)
		);
	}
}

کلاس Display یک پیاده‌سازی مقدماتی از «ویجت بی‌حالت» (StatelessWidget) یا یک value و height است که در سازنده تعیین شده‌اند. پس‌زمینه روی یک گرادیان خطی تنظیم شده و value به صورت متنی در گوشه راست-بالای نمایشگر نشان داده می‌شود.

ویجت KeyPad

در این بخش ویجت KeyPad ماشین حساب را که در فایل lib/key-pad.dart قرار دارد بررسی می‌کنیم:

import 'package:flutter/widgets.dart';
import 'package:flutter_calculator_demo/calculator-key.dart';

class KeyPad extends StatelessWidget {

  @override
  Widget build(BuildContext context) {
  
    return Column(

      children: [
        Row(
          children: <Widget>[
            CalculatorKey(symbol: Keys.clear),
            CalculatorKey(symbol: Keys.sign),
            CalculatorKey(symbol: Keys.percent),
            CalculatorKey(symbol: Keys.divide),
          ]
        ),
        Row(
          children: <Widget>[
            CalculatorKey(symbol: Keys.seven),
            CalculatorKey(symbol: Keys.eight),
            CalculatorKey(symbol: Keys.nine),
            CalculatorKey(symbol: Keys.multiply),
          ]
        ),
        Row(
          children: <Widget>[
            CalculatorKey(symbol: Keys.four),
            CalculatorKey(symbol: Keys.five),
            CalculatorKey(symbol: Keys.six),
            CalculatorKey(symbol: Keys.subtract),
          ]
        ),
        Row(
          children: <Widget>[
            CalculatorKey(symbol: Keys.one),
            CalculatorKey(symbol: Keys.two),
            CalculatorKey(symbol: Keys.three),
            CalculatorKey(symbol: Keys.add),
          ]
        ),
        Row(
          children: <Widget>[
            CalculatorKey(symbol: Keys.zero),
            CalculatorKey(symbol: Keys.decimal),
            CalculatorKey(symbol: Keys.equals),
          ]
        )
      ]
    );
  }
}

ویجت KeyPad یک ستون با پنج ردیف که هر کدام چهار آیتم دارند می‌سازد. ردیف آخر تنها سه آیتم دارد چون کلید صفر به اندازه دو کلید فضا اشغال می‌کند. کلیدها درون کلاس Keys تعریف می‌شوند که در ادامه بررسی خواهیم کرد و در این کلاس و بقیه بخش‌های دیگر اپلیکیشن به صورت صریح مورد ارجاع قرار می‌گیرند بدین ترتیب تعریف رفتار دقیق مطلوب در هر گام با استفاده بیشینه از ثابت‌های از قبل تعریف شده به امری سرراست تبدیل می‌شود.

کلاس KeySymbol

نخستین مفهوم در پس منطق keypad در فایل lib/key-symbol.dart قرار دارد:

import 'package:flutter_calculator_demo/calculator-key.dart';

enum KeyType { FUNCTION, OPERATOR, INTEGER }

class KeySymbol {

  const KeySymbol(this.value);
  final String value;

  static List<KeySymbol> _functions = [ Keys.clear, Keys.sign, Keys.percent, Keys.decimal ];
  static List<KeySymbol> _operators = [ Keys.divide, Keys.multiply, Keys.subtract, Keys.add, Keys.equals ];

  @override 
  String toString() => value;

  bool get isOperator => _operators.contains(this);
  bool get isFunction => _functions.contains(this);
  bool get isInteger => !isOperator && !isFunction;

  KeyType get type => isFunction ? KeyType.FUNCTION : (isOperator ? KeyType.OPERATOR : KeyType.INTEGER);
}

کلید KeySymbol یک پوشش برای آیکون‌های کلیدهای مختلف از قبیل نمادهای جمع و تفریق و اعداد تک‌رقمی (به عنوان رشته) ارائه می‌کند. در این کلاس یک لیست از کلیدهایی تعریف شده که «کلیدهای تابعی» (function keys) هستند و لیست دیگری نیز برای «کلیدهای عملگر» (operator keys) وجود دارد. تفاوت این دو لیست آن است که کلیدهای تابعی حالت محاسبه را به نوعی تغییر می‌دهند و کلیدهای عملگر عملیات‌های مقدماتی ریاضیاتی مانند تقسیم و ضرب را اجرا می‌کنند. یک accessor به نام type نوع یک کلید را بازگشت می‌دهد که تابعی یا عملگر و یا عدد صحیح است. این تشخیص از روی تعلق کلیدها به لیست‌های مختلف تعریف شده صورت می‌گیرد.

ویجت CalculatorKey

اکنون به بررسی تعاریف در فایل lib/calculator-key.dart می‌پردازیم:

import 'package:flutter/material.dart';
import 'package:flutter_calculator_demo/key-controller.dart';
import 'package:flutter_calculator_demo/key-symbol.dart';

abstract class Keys {

  static KeySymbol clear = const KeySymbol('C');
  static KeySymbol sign = const KeySymbol('±');
  static KeySymbol percent = const KeySymbol('%');
  static KeySymbol divide = const KeySymbol('÷');
  static KeySymbol multiply = const KeySymbol('x');
  static KeySymbol subtract = const KeySymbol('-');
  static KeySymbol add = const KeySymbol('+');
  static KeySymbol equals = const KeySymbol('=');
  static KeySymbol decimal = const KeySymbol('.');

  static KeySymbol zero = const KeySymbol('0');
  static KeySymbol one = const KeySymbol('1');
  static KeySymbol two = const KeySymbol('2');
  static KeySymbol three = const KeySymbol('3');
  static KeySymbol four = const KeySymbol('4');
  static KeySymbol five = const KeySymbol('5');
  static KeySymbol six = const KeySymbol('6');
  static KeySymbol seven = const KeySymbol('7');
  static KeySymbol eight = const KeySymbol('8');
  static KeySymbol nine = const KeySymbol('9');
}

class CalculatorKey extends StatelessWidget {

  CalculatorKey({ this.symbol });

  final KeySymbol symbol;
  
  Color get color {

    switch (symbol.type) {

      case KeyType.FUNCTION:
        return Color.fromARGB(255, 96, 96, 96);

      case KeyType.OPERATOR:
        return Color.fromARGB(255, 32, 96, 128);

      case KeyType.INTEGER:
      default:
        return Color.fromARGB(255, 128, 128, 128);
    }
  }

  static dynamic _fire(CalculatorKey key) => KeyController.fire(KeyEvent(key));

  @override
  Widget build(BuildContext context) {

    double size = MediaQuery.of(context).size.width / 4;
    TextStyle style = Theme.of(context).textTheme.display1.copyWith(color: Colors.white);

    return Container(
      
      width: (symbol == Keys.zero) ? (size * 2) : size,
      padding: EdgeInsets.all(2),
      height: size,
      child: RaisedButton(
        shape: RoundedRectangleBorder(borderRadius: BorderRadius.circular(6)),
        color: color,
        elevation: 4,
        child: Text(symbol.value, style: style),
        onPressed: () => _fire(this),
      )
    );
  }
}

نخستین کلاس در این فایل Keys است که به عنوان لیستی از کلیدهای موجود برای کار کردن در سراسر اپلیکیشن محسوب می‌شود. این کلیدها به صوت وهله‌هایی از KeySymbol تعریف شده‌اند که ماهت کلید را در سازنده می‌گیرند و امکان تعریف نماد کلید و شیءهای متناظر را به صورت ثابت‌هایی فراهم می‌سازند که می‌توان از آن‌ها به روشی شیءگرا در سراسر اپلیکیشن استفاده مجدد کرد.

کلاس CalculatorKey نیز در این فایل قرار دارد و یک ویجت بی‌حالت است که تنها یک KeySymbol به عنوان سازنده خود می‌گیرد. CalculatorKey می‌تواند رنگ پس‌زمینه و عرض کلید خود را بر اساس نوع کلید تشخیص دهد. کلیدهای تابعی، عملگر و عدد صحیح، هر کدام رنگ‌های خاص خود را دارند در حالی که کلید صفر دارای عرضی دو برابر کلیدهای نرمال است.

رویدادهای فشردن کلید به وسیله calling _fire مدیریت می‌شود که به نوبه خود رویدادی روی KeyController صادر می‌کند و این رویداد به هر شیئی که به استریم آن گوش می‌دهد ارسال می‌شود.

کلاس KeyController

فایل بعدی که بررسی می‌کنیم به کنترلر کلید مربوط است که در مسیر key-controller.dart قرار دارد:

import 'dart:async';
import 'package:flutter_calculator_demo/calculator-key.dart';

class KeyEvent {

  KeyEvent(this.key);
  final CalculatorKey key;
}

abstract class KeyController {

  static StreamController _controller = StreamController();
  static Stream get _stream => _controller.stream;

  static StreamSubscription listen(Function handler) => _stream.listen(handler as dynamic);
  static void fire(KeyEvent event) => _controller.add(event);

  static dispose() => _controller.close();
}

در این فایل دو کلاس وجود دارد:

  • KeyEvent – پوششی برای CalculatorKey است که برای سهولت کار فشرده شده است.
  • KeyController – پیام‌رسانی رویداد کلید را از طریق Stream و KeyEvent مدیریت می‌کند.

KeyController یک وهله محلی از StreamController و یک ارجاع به استریم درونی آن تنظیم می‌کند و سه متد را ارائه می‌دهد:

  • Listen – به شیء امکان ثبت نام در پیام‌های KeyEvent را می‌دهد.
  • Fire – به شیء امکان ارسال پیام‌های KeyEvent را می‌دهد.
  • Dispose – به اپلیکیشن امکان بستن ملایم StreamController را می‌دهد.

بدین ترتیب با یک نمونه مقدماتی از الگوی «انتشار-ثبت نام» (publish-subscribe) مواجه هستیم که در آن دغدغه شیوه اتصال کامپوننت‌ها به هم از کمترین اهمیت برخوردار است، چون تأثیر اندکی روی خود کامپوننت‌ها دارد. با بهره‌گیری از استریم‌ها و کنترل‌ها امکان افزودن کامپوننت‌های بیشتر و واداشتن آن‌ها به گوش دادن برای اطلاعاتی که نیاز دارند و سپس فراخوانی setState در موارد نیاز و تغییر دادن حالت بر مبنای اطلاعات جدید ارسالی از استریم رویداد که به آن گوش می‌دهد به کاری ساده تبدیل شده است. به طور مشابه همین کامپوننت می‌تواند بدون هیچ تأثیری روی بقیه اپلیکیشن حذف شود، چون داده‌ها به درستی در بقیه بخش‌های برنامه با/بدون شنونده اضافی گردش می‌یابند.

برای کسب اطلاعات بیشتر در مورد برنامه‌نویسی مبتنی بر رویداد ناهمگام با استریم‌ها در دارت می‌توانید به صفحه مستندات (+) آن مراجعه کنید.

کلاس Processor

در انتهای این بخش به بررسی فایلی می‌پردازیم که بار سنگینی بر دوش آن قرار دارد. این فایل processor.dart است:

import 'dart:async';
import 'package:flutter_calculator_demo/calculator-key.dart';
import 'package:flutter_calculator_demo/key-controller.dart';
import 'package:flutter_calculator_demo/key-symbol.dart';

abstract class Processor {

  static KeySymbol _operator;
  static String _valA = '0';
  static String _valB = '0';
  static String _result;

  static StreamController _controller = StreamController();
  static Stream get _stream => _controller.stream;

  static StreamSubscription listen(Function handler) => _stream.listen(handler);
  static void refresh() => _fire(_output);

  static void _fire(String data) => _controller.add(_output);

  static String get _output => _result == null ? _equation : _result;

  static String get _equation => _valA
    + (_operator != null ? ' ' + _operator.value : '')
    + (_valB != '0' ? ' ' + _valB : '');

  static dispose() => _controller.close();

  static process(dynamic event) {
    
    CalculatorKey key = (event as KeyEvent).key;
    switch(key.symbol.type) {

      case KeyType.FUNCTION:
        return handleFunction(key);

      case KeyType.OPERATOR:
        return handleOperator(key);

      case KeyType.INTEGER:
        return handleInteger(key);
    }
  }

  static void handleFunction(CalculatorKey key) {

    if (_valA == '0') { return; }
    if (_result != null) { _condense(); }

    Map<KeySymbol, dynamic> table = {
      Keys.clear: () => _clear(),
      Keys.sign: () => _sign(),
      Keys.percent: () => _percent(),
      Keys.decimal: () => _decimal(),
    };

    table[key.symbol]();
    refresh();
  }

  static void handleOperator(CalculatorKey key) {

    if (_valA == '0') { return; }
    if (key.symbol == Keys.equals) { return _calculate(); }
    if (_result != null) { _condense(); }

    _operator = key.symbol;
    refresh();
  }

  static void handleInteger(CalculatorKey key) {

    String val = key.symbol.value;
    if (_operator == null) { _valA = (_valA == '0') ? val : _valA + val; }
    else { _valB = (_valB == '0') ? val : _valB + val; }
    refresh();
  }

  static void _clear() {

    _valA = _valB = '0'; 
    _operator = _result = null;
  }

  static void _sign() {

    if (_valB != '0') { _valB = (_valB.contains('-') ? _valB.substring(1) : '-' + _valB); }
    else if (_valA != '0') { _valA = (_valA.contains('-') ? _valA.substring(1) : '-' + _valA); }
  }

  static String calcPercent(String x) => (double.parse(x) / 100).toString();

  static void _percent() {

    if (_valB != '0' && !_valB.contains('.')) { _valB = calcPercent(_valB); }
    else if (_valA != '0' && !_valA.contains('.')) { _valA = calcPercent(_valA); }
  }

  static void _decimal() {

    if (_valB != '0' && !_valB.contains('.')) { _valB = _valB + '.'; }
    else if (_valA != '0' && !_valA.contains('.')) { _valA = _valA + '.'; }
  }

  static void _calculate() {

    if (_operator == null || _valB == '0') { return; }

    Map<KeySymbol, dynamic> table = {
      Keys.divide: (a, b) => (a / b),
      Keys.multiply: (a, b) => (a * b),
      Keys.subtract: (a, b) => (a - b),
      Keys.add: (a, b) => (a + b)
    };

    double result = table[_operator](double.parse(_valA), double.parse(_valB));
    String str = result.toString();

    while ((str.contains('.') && str.endsWith('0')) || str.endsWith('.')) { 
      str = str.substring(0, str.length - 1); 
    }

    _result = str;
    refresh();
  }

  static void _condense() {

    _valA = _result;
    _valB = '0';
    _result = _operator = null;
  }
}

کلاس Processor جایی است که اغلب منطق برنامه برای مدیریت تعامل‌های کی‌پد و اجرای محاسبات واقعی در آن قرار دارد. در آغاز چهار مشخصه اصلی روی کلاس برای ذخیره‌سازی متغیرهای ورودی و خروجی داریم:

  • operator_: عملگر ریاضیاتی درخواست شده جاری را نگهداری می‌کند.
  • valA_: عملوند سمت چپ عملگر را نگهداری می‌کند.
  • valB_: عملوند سمت راست عملگر را نگهداری می‌کند.
  • result_: نتیجه محاسبه قبلی را نگهداری می‌کند.

در همین کلاس پیاده‌سازی دیگری از استریم/کنترل استریم وجود دارد که کلاس Calculator از آن برای ثبت نام در پیام‌هایی استفاده می‌کند که شامل مقدار نمایشی به‌روزرسانی شده است. تفاوت اصلی در این جا آن است که متد fire_ با یک کاراکتر زیرخط در ابتدا اعلان شده است و آن را در این کلاس به یک متد خصوصی تبدیل کرده است. این وضعیت مطلوبی است زیرا این تنها جایی است که مقدار واقعی نتیجه محاسبه می‌شود. همچنین یک متد ساده refresh نیز وجود دارد که مقدار خروجی کنونی را برای کامپوننت‌هایی که گوش می‌دهند ارسال می‌کند تا حالت را تنظیم کرده و view را به‌روزرسانی کنند. این متد به صورت عمومی تعریف شده تا امکان گوش دادن کامپوننت‌هایی که درخواست به‌روزرسانی دارند فراهم شود. برای نمونه این اتفاق زمانی که فرایند مقداردهی تکمیل شود رخ می‌دهد.

در ادامه دو مشخصه accessor وجود دارند که محتوای نمایشی را تعیین می‌کنند:

  • output_ در صورتی که null نباشد، result_ و در غیر این صورت equation_ را بازگشت می‌دهد.
  • equation_ در صورت آماده بودن operator_ معادله و در غیر این صورت valA_ را بازگشت می‌دهد.

ترکیب accessor-های زنجیر شده، یک روش ساده برای کنترل خروجی ماشین حساب است و بسته به این که ماشین حساب در چه حالی قرار دارد، یا به نمایش result_ محاسبه قبلی، یعنی محاسبه‌ای که وارد شده و آماده حل شدن است و یا مقدار انتهای سمت چپ می‌پردازد.

این کلاس یک متد dispose نیز دارد که امکان خروج از اپلیکیشن را فراهم می‌کند. در بخش بعدی گروهی از متدها وجود دارند که رویدادهای ورودی کلید را مدیریت می‌کنند:

  • Process – اقدام بعدی که باید اجرا شود را بر اساس نوع KeySymbol انتخاب می‌کند.
  • handleFunction آماده اجرای نوع تابع روی حالت کنونی می‌شود.
  • handleOperator – عملگر ریاضیاتی منتخب را به operator_ انتساب می‌دهد.
  • handleInteger – مقدار عدد کلید را به عملوند مناسب اضافه می‌کند.

متد process جایی است که رویدادها از KeyController به وسیله Calculator به آن فوروارد می‌شوند. این متد از نوع نماد کلید برای انتخاب این که باید یک تابع را اجرا کند، یک عملگر را ذخیره کند یا ورودی عددی را پردازش کند بهره می‌گیرد.

متد handleFunction ابتدا بررسی می‌کند که آیا عملوند سمت چپ (valA_) صفر است یا نه و در چنین حالتی رویداد را کنار می‌گذارد. سپس بررسی می‌کند تا بفهمد آیا باید نتیجه معادله قبلی را با فراخوانی condense_ در عملوند سمت چپ ذخیره کند تا عملیات بعدی بتواند وارد شود یا نه. سپس یک نقشه از تابع‌ها برای انتخاب تابع مطلوب بر مبنای KeySymbol ورودی KeyEvent استفاده می‌شود و KeySymbol به تابع مناسب پس از refresh ارسال می‌شود. این وضعیت عموماً تمیزتر از زنجیره گزاره‌های if-else است و این سطح از گویایی یک قابلیت بارز زبان‌های مدرنی مانند دارت محسوب می‌شود.

متد handleOperator نیز بررسی می‌کند آیا عملوند چپ صفر است یا نه و در این صورت رویدادها را رد می‌کند و نتیجه محاسبه قبلی را در صورت ضرورت در عملوند چپ ذخیره می‌کند. سپس عملوند انتخابی را در operator_ ذخیره کرده و refresh را فراخوانی می‌کند.

متد handleInteger ورودی عددی را در صورت عدم وجود operator_ در عملوند چپ و در غیر این صورت در عملوند راست دریافت می‌کند. در پایان refresh را فراخوانی می‌کند.

گروه بعدی از متدها در کلاس به مدیریت ورودی تابع از کی‌پد می‌پردازند تا حالت پردازنده و مقدار آن را تغییر دهند:

  • clear_: ماشین حساب را ریست کرده و refresh را فرا می‌خواند.
  • sign_: علامت عملوندی را که در حال حاضر ورودی را دریافت می‌کند تغییر می‌دهد.
  • percent / calcPercent_: مقدار عملوند کنونی را بر 100 تقسیم می‌کند.
  • decimal_: یک نقطه اعشاری به انتهای عملوند کنونی الحاق می‌کند.
  • calculate_: محاسبه واقعی را اجرا کرده و نتیجه را در result_ ذخیره می‌کند.
  • result_: اقدام به ذخیره‌سازی result_ در عملوند چپ و آماده‌سازی ورودی بیشتر می‌کند.

متد clear_ به سادگی ماشین حساب را روی مقدار صفر ریست می‌کند. متد sign_ تعیین می‌کند که کدام عملوند باید تغییر یابد و آیا باید یک کاراکتر – به آن اضافه یا کسر شود. متدهای percent_ و decimal_ عمدتاً به طریق مشابهی عمل می‌کنند و عملوند صحیحی را انتخاب و وظایف مربوطه را اجرا می‌کنند.

متد calculate_ هنگامی که هیچ عملگری یا مقدار سمت راست برای اجرای محاسبه روی آن نمانده باشد رویدادها را رد می‌کند و در غیر این صورت از یک نقشه تابع برای انتخاب فرمولی که باید استفاده کرد، محاسبه نتیجه و حذف هر گونه صفر ابتدایی، ذخیره‌سازی مقدار در result_ و در نهایت اجرای refresh بهره می‌گیرد.

سخن پایانی

بدین ترتیب به انتهای بررسی سورس کد این اپلیکیشن ماشین حساب می‌رسیم که کد کامل آن را می‌توانید در این ریپوی گیت‌هاب (+) ملاحظه کنید:

اپلیکیشن ماشین حساب با فلاتر

این ماشین حساب ساده صرفاً با چند صد خط کد پیاده‌سازی شده است و قدرت گویایی که هنگام ساخت اپلیکیشن‌های موبایل با دارت و فلاتر در اختیار ما قرار می‌گیرد را نشان می‌دهد. این قدرت ما را ترغیب می‌کند که از الگوهای طراحی تمیز، استفاده مجدد و مؤثر از کد، ایمنی نوع صریح، و دیگر عادت‌های توسعه‌ای مناسب بهره بگیریم.

همه این قابلیت‌ها موجب شده که فلاتر به گزینه‌ای عالی برای ساخت اپلیکیشن‌های موبایل با کیفیت بالا تبدیل شود که با سرعت بالایی بارگذاری و اجرا می‌شوند، تنها به مقدار نیاز از توان پردازشی و حافظه دستگاه بهره می‌گیرند، تأخیر یا توقف غیرمنتظره‌ای ندارند و می‌توانند به دلیل معماری و کدنویسی تمیز، در آینده به سادگی به‌روزرسانی و نگهداری شوند.

اگر این مطلب برای شما مفید بوده است، آموزش‌های زیر نیز به شما پیشنهاد می‌شوند:

==

بر اساس رای 2 نفر
آیا این مطلب برای شما مفید بود؟
شما قبلا رای داده‌اید!
اگر بازخوردی درباره این مطلب دارید یا پرسشی دارید که بدون پاسخ مانده است، آن را از طریق بخش نظرات مطرح کنید.

«میثم لطفی» در رشته‌های ریاضیات کاربردی و مهندسی کامپیوتر به تحصیل پرداخته و شیفته فناوری است. وی در حال حاضر علاوه بر پیگیری علاقه‌مندی‌هایش در رشته‌های برنامه‌نویسی، کپی‌رایتینگ و محتوای چندرسانه‌ای، در زمینه نگارش مقالاتی با محوریت نرم‌افزار با مجله فرادرس همکاری دارد.

یک نظر ثبت شده در “ساخت اپلیکیشن ماشین حساب با فلاتر — از صفر تا صد

  • سلام.
    من وقتی برنامه رو اجرا می کنم، ماشین حساب نمایش داده میشه ولی با کلیک روی اعداد هیچ اتفاقی نمیوفته.
    مشکل از کجاست؟
    ممنون

نظر شما چیست؟

نشانی ایمیل شما منتشر نخواهد شد. بخش‌های موردنیاز علامت‌گذاری شده‌اند *