javascript中更快的数据访问；for循环和if语句与深度多维数组

我正在构建一个数据结构，用于存储等轴测地图中的平铺数据。我目前正在使用一个3轴的多维数组

var tile = tilesArray[X][Y][Z];

我想知道使用for循环查找数据是否会更快

tilesArray[i] = tileObject

function getTile(x, y, z) {

    //loop through the tiles till we find the right one
    for (var i = 0; i < tilesArray.length; i += 1) {

        //grab the tile
        var tile = tilesArray[i];

        //check the tile position to see if it is the one requested
        if (tile.position[0] = x && tile.position[1] = y && tile.position[2] = z) {
            return tile;
        }   
    }

    //if the tile is not found and we fall out of the for loop return false
    return false;
}

vs

---

我认为在大多数语言中，直接数组访问是最快的，尤其是与循环+函数调用相比。无意冒犯，但这听起来是个坏主意：）保持原样。

我认为在大多数语言中，直接数组访问是最快的，尤其是与循环+函数调用相比。无意冒犯，但这听起来是个坏主意：）保持原样。

这取决于你真正要做的访问类型。主要是插入，然后是顺序访问吗？那么线性存储（如带有访问功能的链表）可能会更好

---

将主要是个人随机访问？那么阵列访问肯定是最快的。

这取决于您真正要执行的访问类型。主要是插入，然后是顺序访问吗？那么线性存储（如带有访问功能的链表）可能会更好

将主要是个人随机访问？那么阵列访问肯定是最快的。

在chrome 12中，物体的速度是chrome 12中的2/3倍

在Firefox4中，对象的速度要慢1000倍。（基本上，FF4中的阵列速度非常快，大约是chrome的1000倍）

由于对象很好，面向对象，并且不涉及有很多间隙的三维数组，我建议使用它作为存储数据的更好方法。

在chrome 12中，物体的速度是chrome 12中的2/3倍

在Firefox4中，对象的速度要慢1000倍。（基本上，FF4中的阵列速度非常快，大约是chrome的1000倍）

---

由于对象很好，面向对象，并且不涉及有很多间隙的三维数组，我建议使用它，因为它通常是存储数据的更好方式。

使用下面的测试并在node.js（Google V8引擎）中执行，数组索引速度大约快3倍。它索引相同的元素。您肯定想尝试索引随机元素，以便更好地了解它们的比较方式

var tilesArray = createTileArray();

function createTileArray()
{
    var rank = 1000;
    var start = new Date();

    // Define
    var ar = new Array(3);

    // Create
    for (var i=0; i < 3; i++)
    {
        ar[i] = new Array(rank);

        for (var j=0; j < rank; j++)
        {
            ar[i][j] = new Array(rank);
        }
    }

    // Fill
    for ( var i = 0; i < 3; i++) {
        for ( var j = 0; j < rank; j++) {
            for ( var k = 0; k < rank; k++) {
                ar[i.valueOf()][j.valueOf()][k.valueOf()] = 3;
            }
        }
    }

    var end = new Date();

    console.log("Created array in: " + (end-start) + "ms");

    return ar;
}

function getTile(array, x, y, z) {

    // loop through the tiles till we find the right one
    for (var i = 0; i < array.length; i++) {

        // grab the tile
        var tile = array[i];

        // check the tile position to see if it is the one requested
        if (tile[0] === x && tile[1] === y && tile[2] === z) {
            return tile;
        }   
    }

    // if the tile is not found and we fall out of the for loop return false
    return false;
}

function arrayIndexing(array, loopCount)
{
    var start = new Date();

    for (var i = 0; i < loopCount; i++) {
        var elem = array[1][2][3];
    }

    var end = new Date();
    console.log("Array indexing in: " + (end-start) + "ms");
}

function loopIndexing(array, loopCount)
{
    var start = new Date();

    for (var i = 0; i < loopCount; i++) {
        getTile(array, 1, 2, 3);
    }

    var end = new Date();

    console.log("Loop indexing in: " + (end-start) + "ms");
}

var loopCount = 1000000;

arrayIndexing(tilesArray, loopCount);
loopIndexing(tilesArray, loopCount);

var tilesArray=createtileray（）；
函数createTilerRay（）
{
var秩=1000；
var start=新日期（）；
//定义
var-ar=新阵列（3）；
//创造
对于（变量i=0；i<3；i++）
{
ar[i]=新数组（秩）；
对于（var j=0；j

使用下面的测试并在node.js（谷歌V8引擎）中执行，数组索引速度大约快3倍。它索引相同的元素。您肯定想尝试索引随机元素，以便更好地了解它们的比较方式

var tilesArray = createTileArray();

function createTileArray()
{
    var rank = 1000;
    var start = new Date();

    // Define
    var ar = new Array(3);

    // Create
    for (var i=0; i < 3; i++)
    {
        ar[i] = new Array(rank);

        for (var j=0; j < rank; j++)
        {
            ar[i][j] = new Array(rank);
        }
    }

    // Fill
    for ( var i = 0; i < 3; i++) {
        for ( var j = 0; j < rank; j++) {
            for ( var k = 0; k < rank; k++) {
                ar[i.valueOf()][j.valueOf()][k.valueOf()] = 3;
            }
        }
    }

    var end = new Date();

    console.log("Created array in: " + (end-start) + "ms");

    return ar;
}

function getTile(array, x, y, z) {

    // loop through the tiles till we find the right one
    for (var i = 0; i < array.length; i++) {

        // grab the tile
        var tile = array[i];

        // check the tile position to see if it is the one requested
        if (tile[0] === x && tile[1] === y && tile[2] === z) {
            return tile;
        }   
    }

    // if the tile is not found and we fall out of the for loop return false
    return false;
}

function arrayIndexing(array, loopCount)
{
    var start = new Date();

    for (var i = 0; i < loopCount; i++) {
        var elem = array[1][2][3];
    }

    var end = new Date();
    console.log("Array indexing in: " + (end-start) + "ms");
}

function loopIndexing(array, loopCount)
{
    var start = new Date();

    for (var i = 0; i < loopCount; i++) {
        getTile(array, 1, 2, 3);
    }

    var end = new Date();

    console.log("Loop indexing in: " + (end-start) + "ms");
}

var loopCount = 1000000;

arrayIndexing(tilesArray, loopCount);
loopIndexing(tilesArray, loopCount);

var tilesArray=createtileray（）；
函数createTilerRay（）
{
var秩=1000；
var start=新日期（）；
//定义
var-ar=新阵列（3）；
//创造
对于（变量i=0；i<3；i++）
{
ar[i]=新数组（秩）；
对于（var j=0；jvar tilesArray = createTileArray();

function createTileArray()
{
    var rank = 1000;
    var start = new Date();

    // Define
    var ar = new Array(3);

    // Create
    for (var i=0; i < 3; i++)
    {
        ar[i] = new Array(rank);

        for (var j=0; j < rank; j++)
        {
            ar[i][j] = new Array(rank);
        }
    }

    // Fill
    for ( var i = 0; i < 3; i++) {
        for ( var j = 0; j < rank; j++) {
            for ( var k = 0; k < rank; k++) {
                ar[i.valueOf()][j.valueOf()][k.valueOf()] = 3;
            }
        }
    }

    var end = new Date();

    console.log("Created array in: " + (end-start) + "ms");

    return ar;
}

function getTile(array, x, y, z) {

    // loop through the tiles till we find the right one
    for (var i = 0; i < array.length; i++) {

        // grab the tile
        var tile = array[i];

        // check the tile position to see if it is the one requested
        if (tile[0] === x && tile[1] === y && tile[2] === z) {
            return tile;
        }   
    }

    // if the tile is not found and we fall out of the for loop return false
    return false;
}

function arrayIndexing(array, loopCount)
{
    var start = new Date();

    for (var i = 0; i < loopCount; i++) {
        var elem = array[1][2][3];
    }

    var end = new Date();
    console.log("Array indexing in: " + (end-start) + "ms");
}

function loopIndexing(array, loopCount)
{
    var start = new Date();

    for (var i = 0; i < loopCount; i++) {
        getTile(array, 1, 2, 3);
    }

    var end = new Date();

    console.log("Loop indexing in: " + (end-start) + "ms");
}

var loopCount = 1000000;

arrayIndexing(tilesArray, loopCount);
loopIndexing(tilesArray, loopCount);

var store = {};

function setTile(x, y, z, tile) {
    k = x*1000000 + y*1000 + z;
    store["K" + k] = tile;
}

function getTile(x, y, z) {
    k = x*1000000 + y*1000 + z;
    return store["K" + k];
}

setTile(1, 7, 5, "1-7-5");
alert (getTile(1,7,5));