用于增量数组的javascript函数

我使用一个函数根据传递给数组的值来增加数组中的值

function depth(x) {
    var dep = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];

    if (x < 10) {
        var deps = dep[0];
        dep[0] = deps + 1;

    } else if (x >= 10 && x < 20) {
        var deps = dep[1];
        dep[1] = deps + 1;

    } else if (x >= 20 && x < 30) {
        var deps = dep[2];
        dep[2] = deps + 1;

    } else if (x >= 30 && x < 40) {
        var deps = dep[3];
        dep[3] = deps + 1;

    } else if (x >= 40 && x < 50) {
        var dep2 = dep[4];
        dep[4] = deps + 1;

    } else if (x >= 50 && x < 60) {
        var deps = dep[5];
        dep[5] = deps + 1;

    } else if (x >= 60 && x < 70) {
        var deps = dep[6];
        dep[6] = deps + 1;

    } else if (x >= 70 && x < 80) {
        var deps = dep[7];
        dep[7] = deps + 1;

    } else if (x >= 80 && x < 90) {
        var deps = dep[8];
        dep[8] = dep2 + 1;

    } else if (x >= 90 && x < 100) {
        var deps = dep[9];
        dep[9] = dep2 + 1;

    } else if (x >= 100 && x < 110) {
        var deps = dep[10];
        dep[10] = deps + 1;


    } else if (x >= 110 && x < 120) {
        var deps = dep[11];
        dep[11] = deps + 1;

    } else if (x >= 120 && x < 130) {
        var deps = dep[12];
        dep[12] = deps + 1;

    } else if (x >= 130 && x < 140) {
        var deps = dep[13];
        dep[13] = deps + 1;

    } else if (x >= 140 && x < 150) {
        var dep2 = dep[14];
        dep[14] = deps + 1;

    } else if (x >= 150 && x < 160) {
        var deps = dep[15];
        dep[15] = deps + 1;


    } else if (x >= 160 && x < 170) {
        var deps = dep[16];
        dep[16] = deps + 1;

    } else if (x >= 170 && x < 180) {
        var deps = dep[17];
        dep[17] = deps + 1;

    } else if (x >= 180 && x < 190) {
        var deps = dep[18];
        dep[18] = dep2 + 1;

    } else if (x >= 190 && x < 200) {
        var deps = dep[19];
        dep[19] = dep2 + 1;

    } else {
        var dep2 = dep[10];
        dep[20] = dep2 + 1;

    }

}

函数深度（x）{
VarDep=[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]；
if（x<10）{
var-deps=dep[0]；
dep[0]=deps+1；
}否则，如果（x>=10&&x<20）{
var-deps=dep[1]；
dep[1]=deps+1；
}否则，如果（x>=20&&x<30）{
var-deps=dep[2]；
dep[2]=deps+1；
}否则，如果（x>=30&&x<40）{
var-deps=dep[3]；
dep[3]=deps+1；
}否则，如果（x>=40&&x<50）{
var dep2=dep[4]；
dep[4]=deps+1；
}否则，如果（x>=50&&x<60）{
var-deps=dep[5]；
dep[5]=deps+1；
}如果（x>=60&&x<70），则为else{
var-deps=dep[6]；
dep[6]=deps+1；
}如果（x>=70&&x<80），则为else{
var-deps=dep[7]；
dep[7]=deps+1；
}如果（x>=80&&x<90），则为else{
var-deps=dep[8]；
dep[8]=dep2+1；
}如果（x>=90&&x<100），则为else{
var-deps=dep[9]；
dep[9]=dep2+1；
}否则如果（x>=100&&x<110）{
var-deps=dep[10]；
dep[10]=deps+1；
}否则如果（x>=110&&x<120）{
var-deps=dep[11]；
dep[11]=deps+1；
}否则如果（x>=120&&x<130）{
var-deps=dep[12]；
dep[12]=deps+1；
}如果（x>=130&&x<140），则为else{
var-deps=dep[13]；
dep[13]=deps+1；
}否则，如果（x>=140&&x<150）{
var dep2=dep[14]；
dep[14]=deps+1；
}否则，如果（x>=150&&x<160）{
var-deps=dep[15]；
dep[15]=deps+1；
}否则如果（x>=160&&x<170）{
var-deps=dep[16]；
dep[16]=deps+1；
}否则如果（x>=170&&x<180）{
var-deps=dep[17]；
dep[17]=deps+1；
}如果（x>=180&&x<190），则为else{
var-deps=dep[18]；
dep[18]=dep2+1；
}否则如果（x>=190&&x<200）{
var-deps=dep[19]；
dep[19]=dep2+1；
}否则{
var dep2=dep[10]；
dep[20]=dep2+1；
}
}

我的问题是，有没有更简洁的方法来实现这一点，或者我是否需要为每个可能的变量编写一个else-if语句？

尝试以下方法：

var index = Math.floor(x/10);
var deps = dep[index];
dep[index] = deps + 1;

---

除了你的else陈述之外，这里还有一个清晰的模式。因此，最简单的方法是对此有一个例外，然后将其余的一起处理

function depth(x) {
    var dep = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
    if (x >= 200) { // case for anything above 200
       return dep[20] = dep[10] + 1;
    }
    dep[Math.floor(x/10)]++;
}

---

您的else案例使它变得有点混乱，但一般来说，这是一种1行程序类型的东西。

类似的东西应该可以解决这个问题，但是由于您的dep是本地的，并且从未返回，所以函数将什么也不做

function depth(x) {
    var dep = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
    if(x < 200) {
      var index = Math.floor(x/10);
      dep[index]++;
    } else {
      dep[20] = dep[10] + 1;
    }
}

函数深度（x）{
VarDep=[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]；
如果（x<200）{
var指数=数学下限（x/10）；
dep[索引]+；
}否则{
dep[20]=dep[10]+1；
}
}

无论如何，正如您可能猜到的，当您看到一个模式时，您可能会将其简化为更简单的模式

如果您的范围为

10

，这意味着您可以将数字除以

10

，以获得索引。您必须使用

Math.floor

，因为

1/2=>0.5

它将尝试将值添加到不存在的索引“0.5”中

Math.floor

将把数字截断为最小值。在我们的例子中，

0,1,2,3,4…

没有全局规则，但当您看到一个模式重复自身时，您只需找到每个案例之间的共同点，您就可以通过将值转换为所有

ifs

的共同点来找到简化大多数情况的方法

重复模式的问题 问题是，您经常重复自己，因为

if/else

语句中的代码有很多相似之处

当您在代码的某些地方发现类似之处时，以某种方式“合并”它们通常是有用的

例如，您可以注意到，除了

10、20、30

etc值之外，语句中的代码完全相同。然后，尝试确定一种方法，使这些

10、20、30、40

依赖于一个唯一的变量，您将使用该变量替换它们

在这种情况下，很容易猜测，因为每次使用的数组键都等于数字除以10。借助JavaScript的内置对象

Math

的一些方法，这是一些单行语句的问题：

function depth(x) {
    var dep = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];

    var nb = Math.floor(x / 10);
    nb = Math.max(nb, 20);
    dep[nb]++;
}

有关数学函数的一些资源：

---

其中一个是删除所有其他项，您可以在开关中进行比较，请参见耶。。。肯定有一种模式。从x到最低10。我在函数中添加了dep以显示我递增的内容，dep数组在脚本中是全局的。@在这里我添加了最后一个条件谢谢你的帮助=）是的，很容易看到一个模式，然后将其简化为这个简短的语句，这是程序员最重要的任务之一：-）你可以更简化它-而不是最后两行你可以键入

dep[nb]++

哈哈，太好了，当你在这里键入文档时，我正在这样做，正如我在下面提到的，

Math.max

不能解决这个问题。其目的不是增加dep[20]，如果它超过200，它是向dep[10]添加一个，并将其分配给dep[20]。很不一样，你说得很对。但我会让我的答案保持原样，因为我找不到比你更好的方法来解决这个问题。这似乎已经完美地解决了它，谢谢你的帮助伟大的东西！希望有帮助。为什么不使用

Math.max（）

而不是

if

语句呢？@Jivan如果del[20]超过200，它不是递增del[20]，而是向dep[10]添加一个，并将其分配给dep[20]。这就是为什么你的仍然是错的。。我认为这很混乱，但考虑到里面的dep[10]，很难想象它能做得更好。@Niall ok明白了，谢谢-在这种情况下，我真的看不到其他（更干净的）方法。只有这个