第 1 题：写一个 mySetInterVal(fn, a, b),每次间隔 a,a+b,a+2b,...,a+nb 的时间，然后写一个 myClear，停止上面的 mySetInterVal

[lgwebdream]

欢迎在下方发表您的优质见解

[Genzhen]

function mySetInterVal(fn, a, b) {
    this.a = a;
    this.b = b;
    this.time = 0;
    this.handle = -1;
    this.start = () => {
        this.handle = setTimeout(() => {
            fn();
            this.time++;
            this.start();
            console.log( this.a + this.time * this.b);
        }, this.a + this.time * this.b);
    }

    this.stop = () => {
        clearTimeout(this.handle);
        this.time = 0;
    }
}

var a = new mySetInterVal(() => {console.log('123')},1000, 2000 );
a.start();
a.stop();

[luobolin]

export interface MySetInterValReturn {
    id: NodeJS.Timeout
}

export const mySetInterVal = (fn: (...args: any[]) => void, a: number, b: number): MySetInterValReturn => {
    let timeObj: MySetInterValReturn = { id: null }

    const helper = (timeout: number): void => {
        timeObj.id = setTimeout(() => {
            fn()
            helper(timeout + b)
        }, timeout);
    }

    helper(a)

    return timeObj
}

export const myClear = (timeObj: NodeJS.Timeout): void => {
    clearTimeout(timeObj)
}


// 测试用例
const timeObj = mySetInterVal((): void => {
    console.log(`time: ${new Date().getSeconds()}`)
}, 1000, 1000)


setTimeout(() => myClear(timeObj.id), 5000);

[zk2401]

function mySetInterVal(fn,a,b) {
    let timer={};
    function setOneTimer(fn,a,b){
        timer.id=setTimeout(()=>{
            console.log(a);
            fn();
            setOneTimer(fn,a+b,b);
        },a)
    }
    setOneTimer(fn,a,b);
    return timer;
}
function myClear(timer){
    clearTimeout(timer.id);
}

//test
const timer=mySetInterVal(()=>{console.log('run')},100,200);
setTimeout(()=>myClear(timer),2000);

[Freeruning]

function mySetInterVal(fn, a, b) {
  let timeCount = 0;
  let timer
  const loop = () => {
    timer = setTimeout(() => {
      fn()
      timeCount++
      loop()
    }, a + timeCount * b)
  }
  loop()
  return () => {
    clearTimeout(timer)
  }
}
//测试
const myClear =mySetInterVal(()=>{console.log('test')},1000,500);
// 清除定时器
myClear()

[leewr]

function mySetInterVal(fun, a, b) {
!mySetInterVal.prototype.maxLimit && (mySetInterVal.prototype.maxLimit = a + 2 * b)
if (a > mySetInterVal.prototype.maxLimit) {
mySetInterVal.prototype.maxLimit = null
return
}
return setTimeout(() => {
mySetInterVal(fun, a + b, b)
fun()
}, a);
}

function myClear(timeId) {
clearTimeout(timeId)
mySetInterVal.prototype.maxLimit = null

}

let timeId = mySetInterVal(() => {
console.log('----', timeId)
}, 1000, 1000)

[ppoollaarr]

class mySetInterVal {
a: number;
b: number;
fn: (...args: any[]) => void;
handle: number;
count: number;

constructor(fn: (...args: any[]) => void, a: number, b: number) {
    this.a = a;
    this.b = b;
    this.fn = fn;
    this.count = 0;
}

start() {
    this.handle = setTimeout(() => {
        this.fn();
        this.count++;
        this.start();
        console.log(this.a + this.count * this.b);
    }, this.a + this.count * this.b);
}

stop() {
    clearTimeout(this.handle);
    this.count = 0;
}

}

let timeObj = new mySetInterVal(
() => {
console.log(1);
},
1000,
1000
);
timeObj.start();

[shenanheng]

function mySetInterVal(fn, a, b) {
  // 停止的标识
  let obj = {
    timer: null,
  };
  let queue = [a, a + b, a + 2 * b];
  return () => {
    function run(arr) {
      if (arr.length) {
        obj.timer = setTimeout(() => {
          fn();
          run(arr);
        }, arr.shift());
      }
    }
    run(queue);
    return obj;
  };
}
function myClear(obj) {
  clearTimeout(obj.timer);
}
let obj = mySetInterVal(
  () => {
    console.log("在哪里");
  },
  1000,
  2000
)();
setTimeout(() => {
  myClear(obj);
}, 3000);

[EmotionBin]

function mySetInterVal(fn, a, b) {
  let currentTimeout = null;
  let counter = 0;
  const step = () => {
    currentTimeout = setTimeout(() => {
      fn();
      counter === 2 ? counter = 0 : counter ++;
      step();
    }, a + counter * b);
  }
  step();
  return () => {
    clearTimeout(currentTimeout);
  }
}
const myClear = mySetInterVal(() => console.log(11), 1000, 2000);
// 11秒后停止
const id = setTimeout(() => {
  myClear();
  clearTimeout(id);
}, 11000);

[cm-space]

function mySetInterVal(fn, a, b) {
this.a = a
this.b = b
this.time = 0
this.fn = fn
this.suspends=true
this.timer = null
}

mySetInterVal.prototype.strap = function () {
this.timer = function () {
setTimeout(() => {
this.fn()
this.time++
console.log(this.a + this.time * this.b)
if(this.suspends){
this.timer()
}
}, this.a + this.time * this.b)
}
this.timer()
}

mySetInterVal.prototype.suspend=function(){
this.suspends=false
}

let maybeCleanUpFn = new mySetInterVal(() => {
console.log('执行回调')
}, 1000, 2000)

maybeCleanUpFn.strap()

setTimeout(function () {
maybeCleanUpFn.suspend()
},100000)

[Bobyoung0719]

let timer = null;

function mySetInterVal(t1, t2) {
  const T = t1 + t2;

  if(t1 > 6000) {
    return myClear();
  }

  timer = setTimeout(() => {
    t2 += t1;
    
    mySetInterVal(t1, t2);
  }, T);
}

function myClear() {
  clearTimeout(timer);
}

mySetInterVal(1000, 1000);

[HuberTRoy]

function getCurrentTime(a, b) {
    let cache = -1

    return function () {
        cache += 1
        return !cache ? a : a + cache*b
    }
}

function mySetInter(fn, a, b) {
    const _getCurrentTime = getCurrentTime(a, b)

    let clear = {
        timer: null
    }
    
    function _setTimeout() {
        return setTimeout(() => {
            fn();
            clear.timer = _setTimeout()
        }, _getCurrentTime())
    }

    clear.timer = _setTimeout()

    return clear
}

function myClear(timer) {
    clearTimeout(timer.timer)
}

let p = mySetInter(() => {console.log('hello world') }, 1000, 1000)