【鸿蒙小白】简单计算器案例代码

于 2024-08-04 20:19:01 发布
阅读量423 收藏 7
点赞数 5
文章标签： 鸿蒙 学习 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79881289/article/details/140911199
版权

项目结构

项目结构

代码

Index

  • 处理显示格式
  • 输入后判断合法性，存入expressions（expressions存表达式拆分数字和符号后的元素）
  • 显示输入输出框、按键
import { CalSymbol, CommonConstants, Symbol, SymbolIcon } from '../common/constants/CommonConstants'
import CalculateUtil from '../common/util/CalculateUtil'
import CheckEmptyUtil from '../common/util/CheckEmptyUtil'
import { PressKeyItem } from '../ViewModel/PresskeyItem'
import keysModel from '../ViewModel/PresskeysViewModel'

@Entry
@Component
struct Index {
  @State calVar:string=''
  @State inputVar:string=''
  @State expressions:string[]=[]

  build() {
    Flex({direction:FlexDirection.Column,justifyContent:FlexAlign.End}) {
      Input({inputVar:this.inputVar,calVar:this.calVar});
      Keys({inputVar:$inputVar,calVar:$calVar,expressions:$expressions})
    }
    .width('100%')
    .height('100%')
  }
}

@Component
struct Input {
  @Prop inputVar:string//输入框结果
  @Prop calVar:string//输出框结果


  build() {
    Flex({direction:FlexDirection.Column,justifyContent:FlexAlign.End}) {
      TextInput({
        text: this.inputVar
      })
        .fontColor('#ff515151')
        .textAlign(TextAlign.End)
        .fontSize((this.inputVar.length > CommonConstants.INPUT_LENGTH_LIM) ? $r('app.float.font_size_small') :
        $r('app.float.font_size_big'))
        .placeholderFont({ size: $r('app.float.font_size_big') })
        .backgroundColor('#ffff')
        .width('100%')
        .height('40%')
        .enabled(false)
      Text(this.calVar)
        .textAlign(TextAlign.End)
        .width('100%')
        .fontSize($r('app.float.font_size_big'))
        .width('100%')
        .height('60%')
    }
    .width('100%')
    .height('30%')
  }
}



@Component
struct Keys {
  Number:PressKeyItem[]=keysModel.getNumberKeys()
  Operation:PressKeyItem[]=keysModel.getOperationKey()
  @Link calVar:string
  @Link inputVar:string
  @Link expressions:string[]


  @Builder KeyItem(key:PressKeyItem,fontsize:Resource,fontcolor:Resource,bgcolor:Resource){
    Text(key.icon)
      .fontWeight(FontWeight.Bold)
      .fontSize(fontsize)
      .fontColor(fontcolor)
      .borderRadius(10)
      .backgroundColor(bgcolor)
      .height('100%')
      .width('100%')
      .textAlign(TextAlign.Center)
      .onClick(()=>{
        if(key.flag===0){
          this.inputSymbol(key.value)
        } else {
          this.inputNumber(key.value)
        }
      })
   }

  /**
   * 输入符号
   */
  inputSymbol(value:string){
    if(CheckEmptyUtil.isEmpty(value))return;
    let len=this.expressions.length
    switch (value) {
      case Symbol.CLEAN:
        this.expressions=[]
        this.calVar=''
        this.inputVar=''
        break;
      case Symbol.DEL:
        this.inputDel(len)
        break;
      case Symbol.EQU:
        if(len===0)return
        this.inputVar=this.calVar
        this.calVar=''
        this.expressions=[]
        this.expressions.push(this.inputVar)
        break;
      default:
        this.inputOperations(len,value)
        break;
    }
    this.formatInputValue();
  }
  //输入回退键
  inputDel(len:number){
    /*console.log('Press Del')*/
    if(len===0){
      return
    }
    let last=this.expressions[len-1]
    let lastLen=last.length
    if(len>0){
      if(lastLen===1){
        this.expressions.pop()
      }else{
        this.expressions[len-1]=last.slice(0,lastLen-1)
      }
    }
    if(this.expressions.length===0){//删除后长度变化 不能用len
      this.inputVar=''
      this.calVar=''
      return
    }
    if(!CalculateUtil.isSymbol(this.expressions[len-1])){
      this.getResult()//实时得到结果
    }
  }
  //输入运算符
  inputOperations(len:number,value:string){

    if(CheckEmptyUtil.isEmpty(value))return;
    // if(len<=0)return
    let last = len > 0 ? this.expressions[len - 1] : undefined;
    let secondLast = len > 1 ? this.expressions[len - 2] : undefined;
    let symbol:string=this.getSymbol(value)

    if(!last) {
      if(value===Symbol.MIN){
        this.expressions.push(symbol)
      }
      return
    }
    else{
      if(!CalculateUtil.isSymbol(last))/*last是数字*/{
        this.expressions.push(this.getSymbol(value))
        return
      }
      else/*last是符号*/{
        if (secondLast) {
          if (!CalculateUtil.isSymbol(secondLast)) /*second是数字*/ {
            if (!(value === Symbol.MIN)) {
              this.expressions.pop()
              this.expressions.push(symbol)
              return
            } else {
              if (last === SymbolIcon.MUL || last === SymbolIcon.DIV) {
                this.expressions.push(symbol)
                return
              } else {
                this.expressions.pop()
                this.expressions.push(symbol)
                return
              }
            }
          } else /*second是符号*/{
            if (value === Symbol.ADD) {
              this.expressions.pop()
              return
            } else if (value === Symbol.MIN) return
            else {
              this.expressions.slice(0, len - 2)
              this.expressions.push(symbol)
            }
          }
        }
      }
    }
  }
  getSymbol(value:string):string{
    if(CheckEmptyUtil.isEmpty(value))return''
    let symbol:string=''
    switch(value){
      case Symbol.ADD:
        symbol=SymbolIcon.ADD
        break;
      case Symbol.MIN:
        symbol=SymbolIcon.MIN
        break;
      case Symbol.MUL:
        symbol=SymbolIcon.MUL
        break;
      case Symbol.DIV:
        symbol=SymbolIcon.DIV
        break;
      default :
        break;
    }
    return symbol
  }
  /**
   * 输入数字
   */
  inputNumber(value:string){
    if(CheckEmptyUtil.isEmpty(value))return;
    let len=this.expressions.length
    let last = len > 0 ? this.expressions[len - 1] : ''
    let secondLast = len > 1 ? this.expressions[len - 2] : undefined


    if(!this.validateEnter(last,value))return
    if(last===''){
      this.expressions.push(value)

    }else{
      if(!secondLast)/*没有second*/{
        this.expressions[len-1]+=value
      }else{
        if(CalculateUtil.isSymbol(secondLast))this.expressions[len-1]+=value
        else if(CalculateUtil.isSymbol(last)) this.expressions.push(value)
      }
    }

    if(this.formatInputValue) this.formatInputValue()
    if (value !== CalSymbol.DOTS) {//实时得到计算结果
      this.getResult();
    }
  }
  //判断输入是否正确
  validateEnter(last:string,value:string):boolean{
    if(value===CalSymbol.PERCENT_SIGN) {
      if (!last) return false//直接加%
      if (CalculateUtil.isSymbol(last))return false//符号后加%
      if(last.endsWith(CalSymbol.PERCENT_SIGN))return false
    }
    else if(value===CalSymbol.DOTS) {
      //TODO 结果初始显示0
      //TODO 只输入. 自动变成0.
      if(last.endsWith(CalSymbol.PERCENT_SIGN))return false
      if(last.indexOf('.')!==-1)return false//已经有小数点了
    }else{
      if(last==='0')return false
    }
    return true
  }
  /**
   * 得到结果
   */
  getResult(){
    let calResult=CalculateUtil.parseExpression(this.deepCopy())//处理表达式逻辑得到的结果
    console.log('getResult:'+calResult)
    if(calResult==='NaN'){
      this.calVar='Error'
      return false//没得到结果
    }else{
      this.calVar=calResult
      return true
    }
  }


  /**
   * 处理显示格式
   */
  //复制expression
  deepCopy():Array<string>{
    let copyExpressions:Array<string>=Array.from(this.expressions)
    return copyExpressions
  }
  //看华为官方给的案例代码，应该是千位后加逗号，但是在我的电脑上没实现
  resultFormat(value: string) {
    let reg = (value.indexOf('.') > -1) ? new RegExp("/(\d)(?=(\d{3})+\.)/g") : new RegExp("/(\d)(?=(?:\d{3})+$)/g");//正则表达式
    return value.replace(reg, '$1,');//replace(patten,replacement) 字符串中patten换成后者
  }
  //输出处理后的表达式
  formatInputValue() {
    let deepExpressions: Array<string> = []
    this.deepCopy().forEach((item:string,index:number)=>{
      deepExpressions[index]=this.resultFormat(item)
    })
    this.inputVar=deepExpressions.join('')
  }


  build() {
    Flex({ direction: FlexDirection.Row }) {
      Grid() {
        ForEach(
          this.Number,
          (key: PressKeyItem) => {
            GridItem() {
              if(key.icon&&key.flag==0) {//是操作符
                this.KeyItem(key, $r('app.float.op_font_size'), $r('app.color.theme_color'), $r('app.color.key'))
              }else{
                this.KeyItem(key, $r('app.float.number_font_size'), $r('app.color.font_color'), $r('app.color.key'))
              }
            }

          }, (key:PressKeyItem) => key.value)
      }
      .columnsTemplate('1fr 1fr 1fr')
      .rowsTemplate('1fr 1fr 1fr 1fr 1fr')
      .columnsGap(1)
      .rowsGap(1)
      .width('75%')
      .height('100%')

      Grid() {
        ForEach(
          this.Operation,
          (key: PressKeyItem) => {
            GridItem() {
              if(key.icon){
                if (key.icon === '=') {
                  this.KeyItem(key, $r('app.float.op_font_size'), $r('app.color.font_color'),
                    $r('app.color.theme_color'))
                } else {
                  this.KeyItem(key, $r('app.float.op_font_size'), $r('app.color.theme_color'),
                    $r('app.color.key'))
                }
              }
            }
          }, (key:PressKeyItem) => key.value)
      }
      .columnsTemplate('1fr')
      .rowsTemplate('1fr 1fr 1fr 2fr')
      .columnsGap(1)
      .rowsGap(1)
      .width('25%')
      .height('100%')
      .padding({ left: 1 })
    }
    .width('100%')
    .height('57%')
    .backgroundColor('#000')
  }
}

CalculateUtil

  • 处理expressions中的数字
  • 完成计算
    • 中序表达式变后序：
      • 数字放队列前后顺序不变
      • 符号放栈，和上一个符号（栈顶元素）比优先级，同级先计算/优先级高的放队列
      • 最后都放到队列中
    • 在队列中按顺序计算（数 数 符号）
import { CalSymbol, CommonConstants, OperationPriority, SymbolIcon } from '../constants/CommonConstants'
import CheckEmptyUtil from './CheckEmptyUtil'

class CalculateUtil{
  /**
   * 判断是否为字符 是返回true
   */
  isSymbol(value:string):boolean{
    return (CommonConstants.OPERATION.indexOf(value)!==-1)
  }

  /**
   * 处理表达式
   */
  parseExpression(expressions:string[]):string{
    if(CheckEmptyUtil.isEmpty(expressions)){
      return 'NaN'
    }
    let len=expressions.length
    let outputStack:string[]=[]
    let outputQueue:string[]=[]

    //处理每一个元素
    expressions.forEach((item:string,index:number)=>{
      //处理百分号
      if(item.indexOf(CalSymbol.PERCENT_SIGN)!==-1){
        expressions[index]=this.mulOrDiv(item.replace('%',''),'100',SymbolIcon.DIV).toString()
      }
      //最后是运算符
      if((index==len-1)&& this.isSymbol(item))expressions.pop()
    })

    while (expressions.length>0) {
      let current:string|undefined=expressions.shift()
      if(current!==undefined){
        if(this.isSymbol(current)){//运算符
          while(outputStack.length>0&&this.comparePriority(current,outputStack[outputStack.length-1])){
            let popVar=outputStack.pop()
            if(popVar!==undefined) outputQueue.push(popVar)
          }
          outputStack.push(current)
        }else outputQueue.push(current)
      }
    }
    while (outputStack.length>0){
      let popVar=outputStack.pop()
      if(popVar!==undefined) outputQueue.push(popVar)
    }
    return this.dealQueue(outputQueue)
  }
  dealQueue(queue:string[]):string{
    if (CheckEmptyUtil.isEmpty(queue)) {
      return 'NaN';
    }
    let outputStack:string[]=[]
    while(queue.length>0){
      let current:string|undefined=queue.shift();//一开始写成pop 注意shift和pop区别
      if(current) {
        if (!this.isSymbol(current)) {
          outputStack.push(current)
        }else{
          let sec:string|undefined=outputStack.pop()
          let fst:string|undefined=outputStack.pop()
          if(sec!==undefined&&fst!==undefined){
            let calResultVar=this.calResult(fst,sec,current)
            outputStack.push(calResultVar)
          }
        }
      }
    }
    if(outputStack.length!==1){
      console.log('StopHere')
      return 'NaN'
    }
    else{
      let finResult:string=outputStack[0]?.endsWith(CalSymbol.DOTS)?
      outputStack[0].substring(0, outputStack[0].length - 1) : outputStack[0];
      return finResult
    }
  }
  calResult(fst:string,sec:string,op:string):string{
    if(CheckEmptyUtil.isEmpty(fst)||CheckEmptyUtil.isEmpty(sec)||CheckEmptyUtil.isEmpty(op)){
      return 'NaN'
    }
    let result=0
    switch (op) {
      case SymbolIcon.ADD:case SymbolIcon.MIN:
        result=this.addOrMin(fst,sec,op)
        break;
      case SymbolIcon.MUL:case SymbolIcon.DIV:
        result=this.mulOrDiv(fst,sec,op)
        break;
    }
    return this.numberToScientificNotation(result)
  }
  /**
   * op1<=op2返回true，反之返回false
   *
   * @param op1,op2
   */
  comparePriority(op1:string,op2:string):boolean{
    if (CheckEmptyUtil.isEmpty(op1) || CheckEmptyUtil.isEmpty(op2)) {
      return false;
    }
    return (OperationPriority[op1]<=OperationPriority[op2])
  }
  addOrMin(fst:string,sec:string,symbol:string){
    let addFlag=(symbol===SymbolIcon.ADD)
    if(this.containScientificNotation(fst)||this.containScientificNotation(sec)){
      if(addFlag)return Number(fst)+Number(sec)
      else return Number(fst)-Number(sec)
    }
    let leftLen:number=fst.split(CalSymbol.DOTS)[1]?fst.split(CalSymbol.DOTS)[1].length:0
    let rightLen:number=sec.split(CalSymbol.DOTS)[1]?sec.split(CalSymbol.DOTS)[1].length:0
    let maxLen:number=Math.max(leftLen,rightLen)
    let multiple=Math.pow(10,maxLen)
    if(addFlag){
      return Number(((Number(fst)*multiple+Number(sec)*multiple)/multiple).toFixed(maxLen))
    }else{
      return Number(((Number(fst)*multiple-Number(sec)*multiple)/multiple).toFixed(maxLen))
    }
  }
  /**
   * 乘除
   */
  mulOrDiv(fst:string,sec:string,symbol:string):number{
    let mulFlag=(symbol===SymbolIcon.MUL)
    if(this.containScientificNotation(fst)||this.containScientificNotation(sec)){
      if(mulFlag)return Number(fst)*Number(sec)
      else return Number(fst)/Number(sec)
    }
    let leftLen:number=fst.split(CalSymbol.DOTS)[1]?fst.split(CalSymbol.DOTS)[1].length:0
    let rightLen:number=sec.split(CalSymbol.DOTS)[1]?sec.split(CalSymbol.DOTS)[1].length:0
    if(mulFlag){
      return Number(fst.replace(CalSymbol.DOTS,''))*Number(sec.replace(CalSymbol.DOTS,''))/Math.pow(10,leftLen+rightLen)
    }else{
      return (Number(fst.replace(CalSymbol.DOTS,''))/Number(sec.replace(CalSymbol.DOTS,'')))*Math.pow(10,rightLen-leftLen)
    }
  }

  containScientificNotation(arg:string){
    return(arg.indexOf('e')!==-1)
  }
  numberToScientificNotation(result: number):string{
    if(result===Number.NEGATIVE_INFINITY||result===Number.POSITIVE_INFINITY)return 'NaN'
    let resultStr:string=JSON.stringify(result)
    if(this.containScientificNotation(resultStr))return resultStr
    if(resultStr.replace(CalSymbol.DOTS,'').replace(SymbolIcon.MIN,'').length<=CommonConstants.NUM_MAX_LEN)return resultStr
    let prefixNum=result>0?1:-1
    result*=prefixNum;
    let suffix=Math.floor(Math.log10(result))
    let prefix=prefixNum*(result*Math.pow(10,-suffix))
    return prefix.toFixed(2).toString()+'e'+suffix.toString()
  }
}

export default new CalculateUtil()

CheckEmptyUtil

（我为什么要另开一个文件放判断置空的方法

class CheckEmptyUtil{
  /**
   * 空返回true
   */
  isEmpty(obj:object|string):boolean{
    return (obj===undefined||obj===null||obj==='')
  }
}
export default new CheckEmptyUtil();

PresskeyItem

按键类：类型flag，代表值：value，显示的符号：icon

export class PressKeyItem{
  flag:number
  value:string
  icon:string

  constructor(flag:number,value:string,icon?:string) {
    this.flag=flag
    this.value=value
    if(flag==0&&icon){
      this.icon=icon
    }else{
      this.icon=value
    }
  }
}

PresskeysViewModel

创建按键数组

import { PressKeyItem } from './PresskeyItem';

export class  PressKeyViewModel{
  getNumberKeys():Array<PressKeyItem>{
    return[
      new PressKeyItem(0,'clean','C'),
      new PressKeyItem(0,'div','÷'),
      new PressKeyItem(0,'mul','×'),
      new PressKeyItem(1,'7'),
      new PressKeyItem(1,'8'),
      new PressKeyItem(1,'9'),
      new PressKeyItem(1,'4'),
      new PressKeyItem(1,'5'),
      new PressKeyItem(1,'6'),
      new PressKeyItem(1,'1'),
      new PressKeyItem(1,'2'),
      new PressKeyItem(1,'3'),
      new PressKeyItem(1,'%'),
      new PressKeyItem(1,'0'),
      new PressKeyItem(1,'.'),
    ]
  }
  getOperationKey():Array<PressKeyItem>{
    return [
      new PressKeyItem(0,'del','◀'),
      new PressKeyItem(0,'min','-'),
      new PressKeyItem(0,'add','+'),
      new PressKeyItem(0,'equ','='),
    ]
  }
}

let keysModel:PressKeyViewModel = new PressKeyViewModel();
export default keysModel as PressKeyViewModel;

CommonConstants

常量

export class CommonConstants {
  static readonly INPUT_LENGTH_LIM:number=9
  static readonly OPERATION:string='+-×÷'
  static readonly E:string='e'
  static readonly NUM_MAX_LEN:number=16
}
export enum Symbol {
  ADD = 'add',
  MIN = 'min',
  MUL = 'mul',
  DIV = 'div',
  CLEAN = 'clean',
  DEL = 'del',
  EQU = 'equ'
}
export enum SymbolIcon{
  ADD = '+',
  MIN = '-',
  MUL = '×',
  DIV = '÷',
}
export enum CalSymbol{
  PERCENT_SIGN='%',
  DOTS='.'
}
type Priority=Record<string,number>
export const OperationPriority:Priority={
  /*SymbolIcon.ADD=1,*/
  '-':1,
  '+':1,
  '×':2,
  '÷':2
}
啊我不会诶
关注
鸿蒙 简易计算器实现案例教程
xq610928的博客
08-22 776
前言： 各位同学大家好，有段时间没有给大家更新文章了，具体多久我也不记得哈，今天是周日有时间就撸了一个鸿蒙的简易计算器的案例分享给大家 希望能帮助到各位同学学习和工作 那么废话不多说我们正式开始 准备工作 华为鸿蒙系统开发初体验 ：[https://www.jianshu.com/p/f94c847c7fdc] 效果图： 具体实现 代码结构 1 slice MainAbilitySlice：计算器交互界面，用于完成界面元素渲染、按钮事件绑定动作。 2 utils MathUtil： 用于计算表
鸿蒙ArkUI开发实战：制作一个【简单计数器】
m0_62167422的博客
04-08 1570
RenderNode 负责一个节点的显示信息，它形成的 Render 树维护着整个界面渲染需要用到的信息，包括位置、大小、绘制命令等。Element 是 Component 的实例，表示一个具体的组件节点，它形成的 Element 树负责维持界面在整个运行时的树形结构，方便计算更新时的局部更新算法等。通过简单计数器示例，读者先了解一下 OpenHarmony 应用的组件、页面布局，点击事件以及 @State 修饰符的作用，最后给简单介绍了一下 OpenHarmony 的页面构建流程。
鸿蒙开发实战案例-计算器（附整套源码）
shudaoshanQAQ的博客
03-05 3988
鸿蒙开发实战案例-计算器（附整套源码）
鸿蒙第一款应用,我的第一个鸿蒙应用（在手表上写一个简单的计算器）
weixin_39976413的博客
05-29 567
鸿蒙发布了，我来尝尝先，写个hello，world过过瘾。尝试在手表上写一个计算器，结果大致如下，这布局有点不好弄啊，将就着吧。上面是先按下数字 56， 再按下 * ， 再按下 2， 再按下 = 的 结果。布局代码如下：background_ability_mainxmlns:ohos="http://schemas.huawei.com/res/ohos"ohos:width="mat...
鸿蒙开发实战案例-计算器（附整套源码）_开源计算器源码(1)
2401_84160087的博客
04-21 677
（**ArkTS、ArkUI开发组件、Stage模型、多端部署、分布式应用开发、音频、视频、WebGL、OpenHarmony****多媒体技术、Napi组件、OpenHarmony内核、Harmony南向开发、鸿蒙项目实战等等）鸿蒙（Harmony NEXT）**技术知识点。我的思路是先把输入的运算式存入字符串，并用空格分开，如1 + 2 * 3，然后把该字符串切分成数组，对数组进行两次遍历，第一次遍历计算乘法和除法，第二次遍历计算加减法，最后输出结果。最后，有很多小伙伴不知道学习哪些鸿蒙开发技术？
2024年HarmonyOS鸿蒙最全软考高级之信息系统案例分析七重奏-《3》(1)，腾讯面试gm
2401_84853495的博客
05-08 488
5、配置审计；6、发布管理和交付。
HarmonyOS应用开发：鸿蒙Js实战，计算器功能开发
08-09 3579
开发计算器最主要的是连续计算，连续计算需要添加计算优先级逻辑，后续考虑通过遍历来判断里面的计算。
鸿蒙计算器源代码.rar
08-31
【鸿蒙计算器源代码】是针对华为自主开发的HarmonyOS操作系统设计的一款计算器应用的源码集合。这款软件因其在鸿蒙系统上的优秀表现和实用性而受到赞誉。开发者可以通过研究这些源代码，深入理解如何在鸿蒙OS上构建...
HTML简易计算器源代码.zip
05-22
HTML简易计算器源代码.zip是一个包含一个简单HTML计算器的项目，主要使用了逆波兰表达式算法来处理计算逻辑，同时结合HTML、CSS和JavaScript技术来构建用户界面和交互功能。这个计算器的设计灵感来源于MIUI计算器，...
小程序源码 简易计算器 (代码+截图)
06-19
小程序源码 简易计算器 (代码+截图)小程序源码 简易计算器 (代码+截图)小程序源码 简易计算器 (代码+截图)小程序源码 简易计算器 (代码+截图)小程序源码 简易计算器 (代码+截图)小程序源码 简易计算器 (代码+截图)小...
HarmonyOS简易计算器
qq_51740844的博客
12-17 1067
计算器是我们生活中经常使用的应用，此项目是基于Harmony实现的简易计算器
Harmony鸿蒙实战开发-计算器app(加减乘除)【源码在文末】
m0_63324772的博客
07-18 644
Harmony鸿蒙实战开发-计算器app(加减乘除)【源码在文末】
【最新鸿蒙开发api12、DevEco5.0版本 | 逆波兰表达式】- 计算器的实现！！！
最新发布
m0_66825548的博客
07-28 1945
我们的HarmonyOS计算器!它不仅能够进行基本的算术运算,还能处理复杂的表达式,甚至包括阶乘和幂运算。通过实现这个看似简单的应用,我们实际上涉及了许多重要的编程概念:正则表达式、栈的使用、字符串处理、UI设计等等。记住,每一个伟大的应用都是从简单的想法开始的。今天的计算器,明天可能就是改变世界的下一个大应用!所以,继续编码,继续创造,让我们一起用HarmonyOS改变世界!最后,如果你在实现过程中遇到了任何问题,不要气馁。就像计算器处理复杂表达式一样,解决问题的过程可能需要一步步来。
harmony实现简易计算器
zqxzqx666的博客
07-15 814
HarmonyOS-简易的计算器实现本计算器是仿造windows系统实现的，实现了基本的功能四则运算，清除，退位，小数点，正负号功能。
鸿蒙应用开发——计算器（1）
J1062517968的博客
06-21 996
本次将会以DevEco Studio为编辑器开发了一个全新的计算器项目，这个计算器项目不仅具有基本的加减乘除功能，在项目后期还会加入一些有趣、特别的功能来体验出该项目的创新性。同时，还会结合了鸿蒙操作系统的特性，进行了界面优化和用户体验的提升，使得整个计算器应用更加便捷、美观、易用。
鸿蒙应用开发——计算器（5）
J1062517968的博客
06-21 625
再之前的文章中我们已经完整的实现了计算器项目的功能，再此次实验中我们将对该计算器项目添加一些有趣的功能来达到创新的功能。
『牛角书』鸿蒙-计算器的实现
weixin_51404541的博客
12-17 1401
经过在学校中的鸿蒙学习后，实现一个简易的鸿蒙应用，代码中还有很多不足，有待继续学习。
【鸿蒙】HarMonyOS的UI组件学习九之计算器
笔触狂放的博客
07-02 4403
计算器是电脑和手机都必不可少的一款软件，今天分享在鸿蒙系统上开发计算器软件。 先看功能效果: 这里演示了一下加法，该计算器中实现了加减乘除求余，开根号，倒数等所有功能。其他功能的演示这里就不浪费篇幅了。 接下来看界面的设计，这里设计了两种边框主题，一个是显示计算过程和结果的两个Text组件的边框，在graphic文件夹下新建xml文件: <?xml version="1.0" encoding="utf-8"?> <shape xmlns:ohos="http://s
鸿蒙DevEco Studio 简单实现：简易计数器
m0_74411635的博客
04-15 1522
State titleArray:string[]=['喝水的次数','吃饭的次数','睡觉的次数']在src/main/ets/pages目录下创建Page2.ets文件。Button('新增计数器')Text('简单计数器')
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值