按照以下说明制作Windows样式的加载栏。

^{（请注意，这与Loading ... Forever不同）}

您的输出应以开头[.... ]。

每次滴答，您都应等待100毫秒，然后将每个点向右移动一个字符。如果点在第十个字符上，则将其移至第一个字符。请注意，在再次输出之前，您应该清除屏幕。输出顺序如下：

[....      ]
[ ....     ]
[  ....    ]
[   ....   ]
[    ....  ]
[     .... ]
[      ....]
[.      ...]
[..      ..]
[...      .]

..然后它永远循环。

规则

• 这是代码高尔夫，所以最短答案会胜出，^{我怀疑我什至会接受一个成功答案}
• 请尽可能提供加载栏的gif文件。

V，17 16 15字节

i[´.¶ ]<esc>ògó$X|p

<esc>是0x1b。

和hexdump：

00000000: 695b b42e b620 5d1b f267 f324 587c 70    i[... ]..g.$X|p

说明

i                       " Insert
[                       " a [
´.                      " 4 .s
¶<space>                " 6 spaces
]<esc>                  " and a ]. Then return to normal mode
ò                       " Recursively do:
 gó                     "  Sleep for 100 milliseconds
 $                      "  Go to the ]
 X                      "  Delete the character to the left of the ]
 |                      "  Go to the [
 p                      "  And paste the deleted character right after the [
                        " Implicit ending ò

CSS / HTML，202 190 186 + 45 = 247 235 231字节

pre{position:relative}x{position:absolute;display:inline-block;width:10ch;height:1em;overflow:hidden}x>x{width:14ch;left:-10ch;animation:1s steps(10,end)infinite l}@keyframes l{to{left:0

<pre>[<x><x>....      ....</x></x>          ]

编辑：由于@Luke，节省了12个 14字节。

PowerShell，67 66字节

for($s='.'*4+' '*6;$s=-join($s[,9+0..8])){cls;"[$s]";sleep -m 100}

-1通过使用缩短的构造函数得益于Beatcracker

用最后一个字符放在其余字符前面的字符串副本替换该字符串，清除屏幕，打印出来，然后休眠100毫秒。

通过使用for循环构造函数节省了很多字节，而不是将逻辑包装在字符串中。

Python 3中，99 93 85 83 + 2（-u标志）字节

^{-12字节归功于ovs
-2字节归功于totalhuman}

import time
s=4*'.'+6*' '
while 1:print(end='\r[%s]'%s);time.sleep(.1);s=s[9]+s[:9]

在线尝试！

Windows批处理，201个 181字节

原来使用老式方法实际上可以节省字节！

@for %%p in ("....      " " ....     " "  ....    " "   ....   " "    ....  " "     .... " "      ...." ".      ..." "..      .." "...      .")do @echo [%%~p]&timeout 0 >nul&cls
@%0

注意：

get-screenrecorder.level
- low grade

get-gpu.level
- horrible

if get-screenrecorder.level == low grade || get-gpu.level == horrible {
     say("GIF may not be accurate");
}

请注意，我的GIF记录器跳过了几帧，使加载栏跳了 :(

Mathematica，67 77字节

+10字节，因为我忘了方括号。

Animate["["<>"....      "~StringRotateRight~n<>"]",{n,1,10,1},RefreshRate->10]

C（GCC） ，126 125 124 123 122 121个 119 118 117 114 115字节

这个使用位掩码来跟踪点的位置。

我不得不添加另一个字节，因为我之前仅输出5个空格。

m=30;f(i){usleep(3<<15);system("clear");for(i=1;i<1920;i*=2)putchar(i^1?i&m?46:32:91);m+=m&512?m+1:m;f(puts("]"));}

在线尝试！

Javascript（ES6），86个字节

setInterval('with(console)clear(),log(`[${x=x[9]+x.slice(0,9)}]`)',100,x='...      .')

JavaScript（ES6）+ HTML，104 85 83字节

f=(s="....      ")=>setTimeout(f,100,s[9]+s.slice(0,9),o.value=`[${s}]`)
<input id=o

• 由于Johan建议我使用an input而不是a ，因此节省了2个字节pre。

试试吧

要>在input代码段中起作用，需要在标签上加上一个结束符。

(f=(s="....      ")=>setTimeout(f,100,s[9]+s.slice(0,9),o.value=`[${s}]`))()

<input id=o>

Noodel，16 15 14 13 字节

[CỤ'Ṁ〜ððÐ]ʠḷẸḍt

]ʠ[Ð。×4¤×6⁺ḷẸḍt

]ʠ⁶¤⁴.ȧ[ėÐḷẸḍt

试试吧：）

怎么运行的

]ʠ⁶¤⁴.ȧ[ėÐḷẸḍt

]ʠ⁶¤⁴.ȧ[ėÐ     # Set up for the animation.
]              # Pushes the literal string "]" onto the stack.
 ʠ             # Move the top of the stack down by one such that the "]" will remain on top.
  ⁶¤           # Pushes the string "¤" six times onto the stack where "¤" represents a space.
    ⁴.         # Pushes the string "." four times onto the stack.
      ȧ        # Take everything on the stack and create an array.
       [       # Pushes on the string literal "[".
        ė      # Take what is on the top of the stack and place it at the bottom (moves the "[" to the bottom).
         Ð     # Pushes the stack to the screen which in Noodel means by reference.

          ḷẸḍt # The main animation loop.
          ḷ    # Loop endlessly the following code.
           Ẹ   # Take the last character of the array and move it to the front.
            ḍt # Delay for a tenth of a second.
               # Implicit end of loop.

更新资料

[Ð]ıʠ⁶¤⁴.ḷėḍt

试试吧：）

不知道为什么这花了我一些时间。无论如何，这将其放置在13个字节处。

[Ð]ıʠ⁶¤⁴.ḷėḍt

[Ð]ıʠ⁶¤⁴.     # Sets up the animation.
[             # Push on the character "["
 Ð            # Push the stack as an array (which is by reference) to the screen.
  ]           # Push on the character "]"
   ı          # Jump into a new stack placing the "[" on top.
    ʠ         # Move the top of the stack down one.
     ⁶¤       # Push on six spaces.
       ⁴.     # Push on four dots.

         ḷėḍt # The main loop that does the animation.
         ḷ    # Loop the following code endlessly.
          ė   # Take the top of the stack and put it at the bottom.
           ḍt # Delay for a tenth of a second.

<div id="noodel" code="[Ð]ıʠ⁶¤⁴.ḷėḍt" input="" cols="12" rows="2"></div>

<script src="https://tkellehe.github.io/noodel/noodel-latest.js"></script>
<script src="https://tkellehe.github.io/noodel/ppcg.min.js"></script>

PHP，67字节

for($s="...      .";$s=substr($s.$s,9,10);usleep(1e5))echo"\r[$s]";

没有意见

C＃，162个 157字节

()=>{for(string o="[....      ]";;){o=o.Insert(1,o[10]+"").Remove(11,1);System.Console.Write(o);System.Threading.Thread.Sleep(100);System.Console.Clear();}};

或整个程序为177个字节

namespace System{class P{static void Main(){for(string o="[....      ]";;){o=o.Insert(1,o[10]+"").Remove(11,1);Console.Write(o);Threading.Thread.Sleep(100);Console.Clear();}}}}

纯bash 68

s=${1:-....      }
printf "[$s]\r"
sleep .1
exec $0 "${s: -1}${s%?}"

MATL，24字节

`1&Xx'['897B@YS46*93hhDT

在MATL在线上尝试一下！或从离线编译器中查看gif：

说明

`        % Do...while
  1&Xx   %   Pause for 0.1 s and clear screen
  '['    %   Push this character
  897B   %   Push [1 1 1 0 0 0 0 0 0 1]
  @      %   Push current iteration index, 1-based
  YS     %   Circularly shift the array by that amount
  46*    %   Multiply by 46 (code point of '.')
  93     %   Push 93 (code point of ']')
  hh     %   Concatenate horizontally twice. Numbers are interpreted as chars
         %   with the corresponding code points
  D      %   Display
  T      %   Push true. Used as loop condition. Results in an infinite loop
         % End (implicit)

果冻，28 27 字节

ṙ©-j@⁾[]ṭ”ÆȮœS.1®ß
897ṃ⁾. Ç

怎么样？

ṙ©-j@⁾[]ṭ”ÆȮœS.1®ß - Link 1, the infinite loop: list of characters s
ṙ                  - rotate s left by:
  -                -   -1 (e.g. "...      ." -> "....      ")
 ©                 -   copy to the register and yield
     ⁾[]           - literal ['[',']']
   j@              - join with reversed @rguments
         Ӯ        - literal '\r'
        ṭ          - tack (append the display text to the '\r')
           Ȯ       - print with no newline ending
              .1   - literal 0.1
            œS     - sleep for 0.1 seconds then yield the printed text (unused)
                ®  - recall the value from the register
                 ß - call this link (1) again with the same arity

897ṃ⁾. Ç - Main link: no arguments
897      - literal 897
    ⁾.   - literal ['.',' ']
   ṃ     - base decompression: convert 897 to base ['.',' '] = "...      ."

C（gcc），202 198 196 189 96 99 88 86 79 77 75 74 73字节

由于数字创伤，节省了7个 8字节。

f(i){usleep(dprintf(2,"\r[%-10.10s]","....      ...."+i%10)<<13);f(i+9);}

或者，如果stdout在每次写入后都无需刷新而无需换行，则无需刷新系统：

C（gcc），70个字节

f(i){usleep(printf("\r[%-10.10s]","....      ...."+i%10)<<13);f(i+9);}

怎么运行的

• usleep( 睡眠下一个返回值（以微秒为单位）。
• dprintf(2,打印到文件描述符2或stderr。这是必要的，因为while stdout是行缓冲的（意味着输出直到打印换行符才显示），stderr而是字符缓冲的（所有输出立即显示）。
• "\r 打印回车（清除当前行）。
• [%-10.10s]"是printf精确长度为10的字符串的格式说明符（无论输出是什么字符串，始终是长度为10的字符串），并在必要时在其右边填充空格。这将包含在括号中。
• ".... ...." 是加载栏。
• +i%10偏移由当前索引模10分的加载条例如，如果i == 3，i % 10等于3抵消由3成使得它等于所述加载条". ...."。
• 当将偏移量的字符串传递给printf格式说明符时，如果需要，它的长度限制为10，并在必要时在末尾添加空格。因此，加载栏将始终在[.... ]和之间[. ...]。

Java 7，139 124字节

String s="....      ";void c()throws Exception{System.out.print("["+s+"]\r");s=(s+s).substring(9,19);Thread.sleep(100);c();}

• 提到\r感谢@Phoenix。

回车\r将“光标”重置为该行的开头，然后可以将其覆盖。不幸的是，在线编译器和Eclipse IDE都不支持此功能，因此我在此答案的末尾添加了一个gif，以从Windows命令提示符处进行显示。

在这里尝试。（稍作修改，因此您不必等待超时即可查看结果。而且，TIO不支持回车，因此在打印每行时不会覆盖前一行。）

说明：

String s="....      ";            // Starting String "....      " on class level
void c()                          // Method without parameter nor return-type
 throws Exception{                // throws-clause/try-catch is mandatory for Thread.sleep
  System.out.print("["+s+"]\r");  //  Print the String between square-brackets,
                                  //  and reset the 'cursor' to the start of the line
  s=(s+s).substring(9,19);        //  Set `s` to the next String in line
  Thread.sleep(100);              //  Wait 100 ms
  c();                            //  Recursive call to same method
}                                 // End of method

输出gif：

Python 2中，81 78个字节

-1个字节（注意到我错过了%sRod 在同一时间提交几乎相同的Python 3版本的用法！）-
2个字节（使用完全人类的想法 -替换s[-1]+s[:-1]为s[9]+s[:9]）

import time
s='.'*4+' '*6
while s:print'\r[%s]'%s,;s=s[9]+s[:9];time.sleep(.1)

围棋，150个 145 132 129 124字节

-5个字节，感谢sudee。

我觉得我没看到足够的东西去...但是我的答案是超过C，所以...请停顿高尔夫球吗？

package main
import(."fmt"
."time")
func main(){s:="....      ";for{Print("\r["+s+"]");Sleep(Duration(1e8));s=(s+s)[9:19];}}

在线尝试！

VBA 32位，_{159 157 143 141} 134个字节

VBA没有允许等待少于一秒的时间的内置函数，因此我们必须从 kernel32.dll

32位声明语句（41个字节）

Declare Sub Sleep Lib"kernel32"(ByVal M&)

64位声明语句（49字节）

Declare PtrSafe Sub Sleep Lib"kernel32"(ByVal M&)

此外，我们必须包含一个DoEvents标志，以避免无限循环使Excel显得无响应。然后，最后一个函数是一个子例程，该子例程不输入任何内容并输出到VBE立即窗口。

立即窗口功能，93字节

匿名VBE立即窗口功能，无需输入即可输出到A1ActiveSheet上的范围

s="...      ....      .":Do:DoEvents:Sleep 100:[A1]="["&Mid(s,10-i,10)&"]":i=(i+1)Mod 10:Loop

旧版本，109字节

立即窗口功能，无需输入即可输出到VBE立即窗口。

s="...      ....      .":i=0:Do:DoEvents:Sleep 100:Debug.?"["&Mid(s,10-i,10)&"]":i=(i+1) Mod 10:Loop

取消格式化

Declare PtrSafe Sub Sleep Lib "kernel32" (ByVal M&)
Sub a()
    Dim i As Integer, s As String
    s = "...      ....      ."
    i = 0
    Do
        Debug.Print [REPT(CHAR(10),99]; "["; Mid(s, 10 - i, 10); "]"
        DoEvents
        Sleep 100
        i = (i + 1) Mod 10
    Loop
End Sub

-2字节，用于删除空白

-30个字节，用于正确计数

-14个字节，用于转换为即时窗口功能

输出量

下面的gif使用完整的子例程版本，因为我懒得用即时窗口功能重新记录下来。

05AB1E，23个字节

'.4×ð6×J[D…[ÿ],Á¶т×,т.W

在线尝试！

说明

'.4×ð6×J                  # push the string "....      "
        [                 # forever do:
         D                # duplicate
          …[ÿ],           # interpolate the copy between brackets and print
               Á          # rotate the remaining copy right
                ¶т×,      # print 100 newlines
                    т.W   # wait 100ms

批处理，99 98字节

感谢SteveFest，节省了1个字节！

（我可以\r从代码中删除，但是本着批量打高尔夫球的精神，我不会。）

@SET s=....      
:g
@CLS
@ECHO [%s%]
@SET s=%s:~-1%%s:~,-1%
@ping 0 -n 1 -w 100>nul
@GOTO g

第一行之后有四个空格。

主要逻辑是修改字符串。%s:~-1%是的最后一个字符%s%，并%s:~0,-1%为所有，但最后一个字符%s%。因此，我们将最后一个字符移到字符串的开头，这将旋转字符串。

Ruby，57个 56字节

s=?.*4+' '*6;loop{$><<"[%s]\r"%s=s[-1]+s.chop;sleep 0.1}

在这里受其他答案的影响很大。

感谢@manatwork，节省了一个字节。同样显然我在计算字符时遇到了麻烦-我使用ST3，而且如果您不注意，显然它将在行中的字符计数中包含换行符。

Perl，69个字节

-3个字节，感谢@Dom Hastings。

$_="....".$"x6;{print"\ec[$_]
";select$a,$a,!s/(.*)(.)/$2$1/,.1;redo}

这select undef,undef,undef,.1是Perl中少于1秒的最短睡眠方式，并且占用大量字节...

稍长（79个字节），有：

@F=((".")x4,($")x6);{print"\ec[",@F,"]\n";@F=@F[9,0..8];select$a,$a,$a,.1;redo}

重击 93 90 96字节

s="...      ....      ."
for((;;)){ for i in {0..9};do printf "\r[${s:10-i:10}]";sleep .1;done;}

在这里查看

无法嵌套{}以获取语法

Groovy，72个字节

s="*"*4+" "*6
for(;;){print("["+s+"]"+"\n"*20);s=s[9]+s[0..8];sleep 100}

讲解

s="*"*4+" "*6 //creates the string "****      "
for(;;){ //classic infinite loop
    print("["+s+"]"+"\n"*20) //prints the string with [ at the beginning and ] at the end. After that some newlines
    s=s[9]+s[0..8] //appends the final char of the string to beginning, creating a cycling illusion
    sleep 100 //100 ms delay
}

Haskell（Windows），159字节

import System.Process
import Control.Concurrent
main=mapM id[do system"cls";putStrLn('[':["....      "!!mod(i-n)10|i<-[0..9]]++"]");threadDelay(10^5)|n<-[0..]]

说明

mapM id             sequentially perform each IO action in the following list
[                   start a list comprehension where each element is...
  do                  an IO operation where
    system "cls";       we clear the screen by calling the windows builtin "cls"
    putStrLn(           then display the string...
      '[':                with '[' appended to
      [                   a list comprehension where each character is...
        "....      "!!       the character in literal string "....      " at the index
        mod(i-n)10          (i - n) % 10
      |i<-[0..9]]         where i goes from 0 to 9
      ++"]"             and that ends with ']'
    );
    threadDelay(10^5)   then sleep for 100,000 microseconds (100 ms)
|n<-[0..]]          where n starts at 0 and increments without bound

Haskell的纯度使生成循环点图案有些复杂。我最终创建了一个嵌套列表推导，它按照应该输出的顺序生成了一个无限的字符串列表，然后又添加了适当的IO操作。

Ruby，61个字节

如果规范是让点向左滚动而不是向右滚动，则将节省1个字节，因为rotate!没有参数会将数组向左移动一次。

s=[?.]*4+[' ']*6
loop{print ?[,*s,"]\r";s.rotate!9;sleep 0.1}

GNU sed（带有exec扩展名），64

分数包括+1 -r。

s/^/[....      ]/
:
esleep .1
s/[^. ]*(.+)(.)].*/\c[c[\2\1]/p
b

c，100

char *s="....      ....     ";main(i){for(i=0;;i=(i+9)%10)dprintf(2,"[%.10s]\r",s+i),usleep(3<<15);}