有人能告诉我为什么这个JavaScript代码不是'；t按顺序排列阵列？

实时代码：

//输入数组：
var输入=[28,32,21,11,8,2,14,32,64]；
//变量声明。a=目前为止的最高数字，b=该数字的位置
entireLoop：
对于（变量i=1；i输入[i-1]）
{
对于（变量o=i；o>=0；o--）
{
如果（输入[i-1]>输入[o]）
{
输入拼接（i，0，输入[o]）；
输入。拼接（（o+1），1）；
继续整个循环；
}
else if（输入[o]>输入[0]）
{
输入拼接（0,0，输入[o]）；
输入。拼接（（o+1），1）；
继续整个循环；
}
}
}
}
文件编写（输入）；

我试着从最大到最小排列数组，但是有一个32被卡住了。我知道有排序方法，但我是个新手，想自己试试。

**edit** 首先看一看数组的本机.sort（）方法。它保持原始数组不变，并接受一个比较函数。后者使得.sort（）非常强大

var input = [28,32,21,11,8,2,14,32,64];

var low2high = function ( a , b ) {
    return a > b;
};

var high2low = function ( a , b ) {
    return a < b;
};

var resultHigh2low = input.sort( high2low ); // [ 64,32,32,28,21,14,11,8,2 ];
var resultLow2high = input.sort( low2high ); // [ 2,8,11,14,21,28,32,32,64 ];

让我们一步一步地了解它：

var bubbleSort = function ( list , comparison ) {
    ..code..
}

我们的函数接受两个参数，第一个是数组，第二个是可选的比较函数

var swapped;
var i = list.length;
var val;

我们将列表的长度存储在变量

i

下，并声明两个空变量（

swapped

和

val

），我们稍后将使用它们

list = [].concat( list ); // do not destroy original

我们使用

[].concat（array）

克隆列表，并覆盖本地

列表

变量，使原始变量保持不变

comparison = ( typeof comparison == "function" ) ? comparison : function(a,b){return a > b;}

我们测试

比较

参数的

类型，如果它是
函数
我们就使用它，否则我们就依赖于自己的
比较
函数。如果
a
大于
b
，我们的回退比较函数将返回
true

do {
    ..code..
} while ( swapped );

do/while循环将至少运行一次，我们的
交换的
变量当前是
未定义的
，因此它将被解释为falsy。如果我们的
比较
函数返回true，则发生交换，并且
交换的
变量将设置为true，因此它将再次循环

while ( --i ) {
    ..code..
}

在这里，我从列表的长度向下循环，
--
操作符放在
I
变量之前，以确保在任何事情之前先处理它，
I--
将在
之后熄灭，而
求值会导致错误的结果，因为
list[list.length]
不存在。我总是这样做（也许是坏习惯），但如果它让你困惑，那就绝对透明

if ( i && comparison( list[ i ] , comparison[ i-1] ) ) {
    ..code..
}

首先，我们检查
i
是否有一个真实值（0的计算结果为falsy），然后运行
comparison
函数，将
list[i]
和
list[i-1]
作为
a
和
b
参数传递。如果
比较
函数返回
真
，则执行交换

val = list[ i ];
list[ i ] = list[ i - 1 ];
list[ i - 1] = val;
swapped = true;

在这里，我不使用
.splice（）
方法执行交换，这只是一个有根据的猜测，但我认为直接赋值比函数调用更快。我使用
val
变量作为占位符。交换完成后，我将
swapped
设置为true，这样我们的do/while循环将继续

return list;

嗯。。。返回结果

我排除了一些检查，比如当列表的长度为0时我们该怎么做等等。基本上，在编写助手函数时，我们还需要处理错误处理。例如，当传递的比较参数不是函数时抛出TypeError，确保比较方法返回布尔值等等。
**edit**
//INPUT ARRAY:
var input = [28,32,21,11,8,2,14,32,64];
//VARIABLE DECLARATION. a = highest number so far, b = position of that number
for (var i = 1; i<input.length; i++)
{
    if(input[i] > input[i-1])
    {
        for(var o = i-1; o>=0; o--)
        {
            if(input[i] > input[o])
            {
                input.splice(i+1,0,input[o]);
                input.splice((o),1);
                i--;
            }       
        }
    }
}
document.write(input);

首先看一看数组的本机.sort（）方法。它保持原始数组不变，并接受一个比较函数。后者使得.sort（）非常强大

var input = [28,32,21,11,8,2,14,32,64];

var low2high = function ( a , b ) {
    return a > b;
};

var high2low = function ( a , b ) {
    return a < b;
};

var resultHigh2low = input.sort( high2low ); // [ 64,32,32,28,21,14,11,8,2 ];
var resultLow2high = input.sort( low2high ); // [ 2,8,11,14,21,28,32,32,64 ];

让我们一步一步地了解它：

var bubbleSort = function ( list , comparison ) {
    ..code..
}

我们的函数接受两个参数，第一个是数组，第二个是可选的比较函数

var swapped;
var i = list.length;
var val;

我们将列表的长度存储在变量
i
下，并声明两个空变量（
swapped
和
val
），我们稍后将使用它们

list = [].concat( list ); // do not destroy original

我们使用
[].concat（array）
克隆列表，并覆盖本地
列表
变量，使原始变量保持不变

comparison = ( typeof comparison == "function" ) ? comparison : function(a,b){return a > b;}

我们测试
比较
参数的
类型，如果它是
函数
我们就使用它，否则我们就依赖于自己的
比较
函数。如果
a
大于
b
，我们的回退比较函数将返回
true

do {
    ..code..
} while ( swapped );

do/while循环将至少运行一次，我们的
交换的
变量当前是
未定义的
，因此它将被解释为falsy。如果我们的
比较
函数返回true，则发生交换，并且
交换的
变量将设置为true，因此它将再次循环

while ( --i ) {
    ..code..
}

在这里，我从列表的长度向下循环，
--
操作符放在
I
变量之前，以确保在任何事情之前先处理它，
I--
将在
之后熄灭，而
求值会导致错误的结果，因为
list[list.length]
不存在。我总是这样做（也许是坏习惯），但如果它让你困惑，那就绝对透明

if ( i && comparison( list[ i ] , comparison[ i-1] ) ) {
    ..code..
}

首先，我们检查
i
是否有一个真实值（0的计算结果为falsy），然后运行
comparison
函数，将
list[i]
和
list[i-1]
作为
a
和
b
参数传递。如果
比较
函数返回
真
，则执行交换

val = list[ i ];
list[ i ] = list[ i - 1 ];
list[ i - 1] = val;
swapped = true;

在这里，我不使用
.splice（）
方法执行交换，这只是一个有根据的猜测，但我认为直接赋值比函数调用更快。我使用
val
变量作为占位符。交换完成后，我将
swapped
设置为true，这样我们的do/while循环将继续

return list;

嗯。。。返回结果

<