关于微信小程序使用JavaScript实现斐波那契数列

使用JavaScript，通过在微信小程序端做UI展示

根据给定的正整数n计算第n个斐波那契数。下列基本要求必须完成：
1、 设计一个交互界面（例如菜单）供用户选择，如果可能，最好是
一个图形化用户界面。
2、 利用迭代算法寻找不超过编程环境能够支持的最大整数的斐波
那契数是第几个斐波那契数。（Java：231-1 for int, 263-1 for long;C、
C++、Python 查阅相关资料）
3、 根据第二步计算的最大的斐波那契数序号n，采用递归方式计算
第n个斐波那契数，看其是否可以在 1 分钟内完成。
4、 利用递归算法计算你的计算机能够在 30 秒内计算出的最大斐波那契数是第几个，计算出下一个斐波那契数的时间是多少，利用
迭代算法求解同样的问题。
5、 利用公式 F(n) = [n/sqrt(5)]快速计算第n个斐波那契数，找出出
现误差时的最小 n 值。
6、 利用矩阵相乘方法计算第n个斐波那契数。
7、 对于相同的输入n值，比较上述四种方法的基本操作次数，以掌
握对数、线性和指数增长率的极大差别。

wxml

<view class="box1">
  <view>微信小程序能够支持的最大整数斐波那契数：</view>
  <text>{{count}}</text>
  <view>值为：{{result}}</view>
  <button type="primary" size="mini" class="btn0" bindtap="fibonacci">按下求最大数</button>
</view>
<view class="box2">
  <lable>请输入第n个数：</lable>
  <input bindinput="handInput">{{number}}</input>
  </view>
<view class="box3">
  <view>递归计算的第n个值：</view>
  <text>{{i1}}</text>
  <view class="time">递归花费的时间为：{{time}}毫秒</view>
  <button type="primary" size="mini" class="btn1" bindtap="callReFibo">递归法</button>
</view>
<!-- 递归花费时间 -->
<view class="box4">
  <view>递归花费三十秒能计算出的最大数：</view>
  <text>{{count2}}</text>
  <button type="primary" size="mini" class="btn2" bindtap="reFibo_time">按我</button>
</view>
<!-- <button bindtap="">迭代法最大数</button> -->
<!-- 公式法 -->
<view class="box4">
  <view>公式法计算的第n个值</view>
  <text>{{formulaResult}}</text>
  <button type="primary" size="mini" class="btn2" bindtap="callFormula">按我</button>
</view>
<!-- 矩阵法 -->
<view class="box4">
  <view>矩阵法计算的第n个值</view>
  <text>{{matrixResult}}</text>
  <button type="primary" size="mini" class="btn2" bindtap="call_matrix">按我</button>
</view>
<!-- 迭代法 -->
<view class="box4">
  <view>迭代法计算的第n个值</view>
  <text>{{res}}</text>
  <button type="primary" size="mini" class="btn2" bindtap="fb">按我</button>
</view>
<view class="box4">
  <view>公式法计算出现误差的n值</view>
  <text>{{error}}</text>
  <button type="primary" size="mini" class="btn2" bindtap="minError">按我</button>
</view>

wxss

/* pages/home/home.wxss */
body{
  width: 100%;
}
page{
  background: #eeeeee;
}
.box1{
  width: 704rpx;
  padding-left: 40rpx;
  padding-top: 10rpx;
  border-radius: 12rpx;
  background: #ffffff;
  margin: 14rpx auto;
  padding-bottom: 20rpx;
  font-size: 30rpx;
  line-height: 40rpx;
  color: #141414;
}
.box1 view{
  margin:0 auto;
  letter-spacing: 2rpx;
}
.btn0{
  margin-top: 40rpx;
  position: relative;
  right: -440rpx;
}
.btn1{
  /* right:-565rpx;
  top:-50rpx; */
  position: absolute;
  right: 30rpx;
}
.btn2{
  position: absolute;
  right: 30rpx;
}
.box2{
  width: 704rpx;
  padding-left: 40rpx;
  padding-top: 10rpx;
  border-radius: 12rpx;
  background: #ffffff;
  margin: 18rpx auto;
  padding-bottom: 20rpx;
}
.box2 input{
  width:300rpx;
  height: 70rpx;
  text-align: center;
  border: #3D4E96 2rpx solid;
  margin:10rpx auto;
  border-radius: 10rpx;
}
.box3{
  height: 245rpx;
  width: 704rpx;
  padding-left: 40rpx;
  padding-top: 10rpx;
  border-radius: 12rpx;
  background: #ffffff;
  margin: 14rpx auto;
  /* padding-bottom: 20rpx; */
  font-size: 30rpx;
  line-height: 40rpx;
  color: #141414;
}
.time{
  margin-top: 30rpx;
}
.box3 text{
  display: block;
  margin-top: 10rpx;
}
.box4{
  height: 130rpx;
  width: 704rpx;
  padding-left: 40rpx;
  padding-top: 10rpx;
  border-radius: 12rpx;
  background: #ffffff;
  margin: 14rpx auto;
  /* padding-bottom: 20rpx; */
  font-size: 30rpx;
  line-height: 40rpx;
  color: #141414;
}

js

var util=require('../../utils/util.js');
Page({
  /**
   * 页面的初始数据
   */
  data: {
    result:'',
    count:'',
    res:0,
    i1:0,
    number:0,
    time:0,
    count1:0,
    count2:0,
    formulaResult:0,
    matrixResult:0,
    error:0
  },
// 迭代算法求最大数
  fibonacci:function(e){
    let a=1;
    let b=1;
    let c=2;
    let count=3;
    while(c<9007199254740991 ){
      a=b;
      b=c;
      c=a+b;
      count++;
    }
    this.setData({
      result:b,
      count:count
    })
  },
  // 迭代法
  fb:function() {
    let a= 1,b= 1,res=2;
    for(var i=3;i<=this.data.number;i++){
        res = a + b;
        a = b;
        b = res;
    }
    this.setData({
      res:res
    })
  },
  // 递归算法核心
  reFibo:function(n) {
    let result=0;
    if(n<=0)
     result= 0;
    if(n==1||n==2)
     result= 1;
    if(n>2){
      result=this.reFibo(n-1)+this.reFibo(n-2);
    }
    return result;
  },
  // 递归运算第n个数
  callReFibo:function(e) {
    let startTime=new Date().getTime()
    this.setData({
      i1:this.reFibo(this.data.number)
    })
    let endTime=new Date().getTime()
    // 花费时间
    this.setData({
      time:endTime-startTime
    })
  },
  handInput(e) {
    this.data.number=e.detail.value;
  },
  // 迭代法固定时间内能计算的最大数
  maxCount:function() {
    let a=1;
    let b=1;
    let c=2;
    let count=3;
    let count1=0
    let startTime=new Date().getTime();
    let endTime=new Date().getTime();
    while (endTime < startTime+300) {
      a = b;
      b = c;
      c = a + b;
      console.log(a)
      count++;
      endTime=new Date().getTime();
    }
    count1=count
    console.log(count1)
    console.log(a,b,c)
  },
  // 递归花费时间能计算出的最大数 count2
  reFibo_time:function(e) {
    let startTime=new Date().getTime()
    let count=3;
    let endTime=0;
    while(endTime<startTime+30000){
      count++;
      this.reFibo(count)
      endTime=new Date().getTime()
    }
    this.setData({
      count2:count
    })
    return count;
  },
// 公式法 result
formula:function(n) {
  let result=0
  let temp=Math.sqrt(5.0)
  let a=(1+temp)/2
  let b=(1-temp)/2
  result=(1.0/temp)*(Math.pow(a,n)-Math.pow(b,n))
  return result
},  
callFormula:function() {
  this.setData({
        formulaResult:this.formula(this.data.number)
      })
} ,
matrix:function(n) {
  var base = [
    [1, 1], 
    [1, 0]
  ]  //元矩阵，这里可以把元矩阵看做是2**0=1
  var ans = [
    [1, 0], 
    [0, 1]
  ]  //结果矩阵  
    while (n){
      if (n & 1){  //取n的二进制的最后一位和1做与运算，如果最后一位是1，则进入if体内部
      ans = this.multi(ans, base)   //如果在该位置n的二进制为1，则计算ans和base矩阵
      } 
      base = this.multi(base, base)   //base矩阵相乘，相当于初始base矩阵的幂*2
      n >>= 1   //n的二进制往右移一位
    }
  return ans[0][1]    //最后获取到的二阶矩阵的[0][1]即f(n)的值
},
// 矩阵相乘
multi:function(a,b) {
  let c=[[0,0],[0,0]] 
   c[0][0] = a[0][0]*b[0][0]+a[0][1]*b[1][0];
   c[0][1] = a[0][0]*b[0][1]+a[0][1]*b[1][1];
   c[1][0] = a[1][0]*b[0][0]+a[1][1]*b[1][0];
   c[1][1] = a[1][0]*b[0][1]+a[1][1]*b[1][1];
   return c;
},
//调用矩阵法
call_matrix:function() {
  let a=this.matrix(this.data.number)
  this.setData({
    matrixResult:a
  })
},
//计算误差
minError:function(e){
  let n=4;
  let a=this.matrix(n)
  let b=Math.round(this.formula(n))
  while(a==b){
    n++
    a=this.matrix(n)
    b=Math.round(this.formula(n))
  }
  this.setData({
    error:n
  })
},

  /**
   * 生命周期函数--监听页面加载
   */
  onLoad(options) {
  },
})

在js部分其中还是有很多不足。