Swift 用于（增加时间延迟），具体取决于对象计数

一道数学题。我正在尝试按顺序设置对象的动画，但我无法找出允许我平滑设置延迟的公式。比如说，如果我的数组中有2个对象，我希望它们能够以I*0.25延迟几乎正常地进行动画制作，但是如果我有25个对象，我希望它们能够相当快地进行动画制作。是的，我可以尝试设置手动比率切换。计数，但我认为应该有一个很好的公式

for (i,object) in objects.enumerated() {
    object.animate(withDelay: (i * 0.25) / objects.count)
}

---

您可以使用下面的函数，这取决于前面指定的对象数，如果阵列将有更多的对象，则每个动画将以较少的延迟执行，但第一个项目的延迟将比后者更长：

for (i,object) in objects.enumerated() {
    object.animate(withDelay: ((1/((i+1)*0.5)) * 0.25) / objects.count)
}

有很多偏执，但我希望它会增加可读性，而且我应用了I+1，这样第一项就不会有被零除的问题

通过这个公式，我希望当你的数组有大量的对象时，延迟会逐渐而平稳地减少

注意：

• 如果您认为数组中没有太多元素时延迟太大（这将降低“objects.count”的数量。请尝试将

  objects.count

  替换为

  （2*objects.count）

• 另外，如果您认为数组中有很多元素（这将增加“objects.count”的数量）时，情况正好相反（延迟不大）。请尝试将

  objects.count

  替换为

  （objects.count/2）

---

你最好选择一个每次都会发生的动画时间，不管变量有多大

let animateTime = 2 // 2 secs
let animateTimePerObject:Double = animateTime/objects.count
for (i,object) in objects.enumerated() {
    object.animate(withDelay: (i * animateTimePerObject) 
}

假设有10个对象，您希望设置动画2秒。这将设置

animateTimePerObject=2/10=.2

每个项目将延迟

i（无论它们在什么位置）*每个对象的动画时间

。因此，按顺序，

0,0.2,0.4,0.6,0.8,0.1,0.12,0.14,0.16,0.18,0.2

对于2个对象也可以这样做
或者你可以做一个

log

函数，允许增长，但速度较慢
添加此函数以创建自定义日志功能

func logC(val: Double, forBase base: Double) -> Double {
    return log(val)/log(base)
}

for (i,object) in objects.enumerated() {
    let delay = i == 0 ? .25 : logC(Double(i)*10, forBase: 10) * 0.25
    object.animate(withDelay: delay)
}

This will slow down your 0.25*i rate to a much slower one.

0 -> .25
1 -> Log(20, base: 10) = 1.3 * 0.25 = .325
...
25 -> Log(250, base: 10) = 2.3979 * 0.25 = .6 

它会在哪里

0 -> .25
1 -> .25 * 2 = .5
25 -> .25 * 25 = 6.25

你可以随心所欲地使用log函数，但这些只是一些想法。至于你在寻找什么样的算法，还不明确
注意：这里可能有一些语法问题，使用了

Double

s和

Int

s，但您可以调整！）
比较日志和Sqrt:

func logC(val: Double, forBase base: Double) -> Double {
    return log(val)/log(base)
}

for i in 0..<25 {
    let delay = i == 0 ? 0.25 : pow(logC(val: Double(i)*10, forBase: 10) * 0.25, log(1/Double(i))) * 0.45
    let delay2 = i == 0 ? 0.25 : sqrt(Double(i)) * 0.5
    print(delay, delay2)
}

0.25 0.25
0.45 0.5
0.9801911408397829 0.7071067811865476
1.3443747821649137 0.8660254037844386
1.5999258430124579 1.0
1.7853405889097305 1.118033988749895
1.9234257236285595 1.224744871391589
2.0282300761096543 1.3228756555322954
2.1088308307833894 1.4142135623730951
2.1713433790123178 1.5
2.2200343505615683 1.5811388300841898
2.2579686175608598 1.6583123951777
2.2874024254699274 1.7320508075688772
2.3100316733059247 1.8027756377319946
2.32715403828525 1.8708286933869707
2.33977794890637 1.9364916731037085
2.348697701417663 2.0
2.3545463958925756 2.0615528128088303
2.357833976756366 2.1213203435596424
2.358975047645847 2.179449471770337
2.35830952737025 2.23606797749979
2.3561182050020992 2.29128784747792
2.35263460234384 2.345207879911715
2.348054124507179 2.3979157616563596
2.3425411926260447 2.449489742783178

func logC（val:Double，forBase:Double）->Double{
返回日志（val）/日志（基本）
}
对于0中的i，假设第一个对象的动画速度比第十个对象快得多，但你仍然不希望它太长，因为对象的数量增加了，对吗？为了得到一个公式，你需要有一个明确的目的“我无法找出允许我平滑设置延迟的公式”什么样的行为对你来说是平滑的？你需要首先回答这个问题。你说的是持续时间，我问的是动画开始前的延迟。假设所有对象的持续时间都相同谢谢你的时间，但是你的公式会产生不一致的结果：（如果我使用original，它可以用于1-3个对象。但是如果我使用超过10个，它会非常快地产生延迟，如0.001等。如果我使用objects.count/2或更多，它会崩溃。另外，我希望延迟随着索引（i）的进度而增加。）不减少7个对象延迟是：0.07142857142857142 0.035714285714285718571 0.023809523809523808 0.017857142857142856 0.0142857142857185714287 0.011904761904761904 0.01020408163265306，我想要像这样的0.1 0.2 0.3 0.4等等，但对于3个对象，我很想看到：0.25 0.45谢谢。到目前为止，你的日志公式总比什么都没有好：）很高兴我能提供帮助！您可以将系数添加到日志函数中，使其变短或变长，它将以日志速率增加/减少。我使用了logC（Double（I）*10，forBase:10）但是你可以改变10中的任何一个，然后玩数值游戏。另外，如果这是你目前接受的答案，别忘了接受！我已经玩了所有的数值组合、混合、分割等，但仍然不完美。最后一半彼此太近，所以我等着，也许有人会想出更好的解决方案，如果没有，你会得到一个cReDIT：）关于这个<代码>让延迟＝i＝0？0.25：POW（LogC（Val:双（i）* 10，FBASE：10）* 0.25，log（1 /双（i）））* 0.45 < /代码>此更新只增加了中间的延迟间隙，但端部的一半元素仍然彼此非常接近（如0.02之间）。