相关疑难解决方法(0)

在Javascript中我怎么能找到0到100之间的素数？我已经考虑过了,我不知道如何找到它们.我想做x%x,但我发现了明显的问题.这是我到目前为止所做的:但不幸的是,这是有史以来最糟糕的代码.

var prime = function (){
var num;
for (num = 0; num < 101; num++){
    if (num % 2 === 0){
        break;
    }
    else if (num % 3 === 0){
        break;
    }
    else if (num % 4=== 0){
        break;
    }
    else if (num % 5 === 0){
        break;
    }
    else if (num % 6 === 0){
        break;
    }
    else if (num % 7 === 0){
        break;
    }
    else if (num % 8 === 0){
        break;
    }
    else if (num …

我遇到了其他人写的这个小型JavaScript程序(在可汗学院):

/*vars*/
frameRate(0);
var Sz=100;
var particles=1000;
scale(400/Sz);
var points=[[floor(Sz/2),floor(Sz/2),false]];
for(var i=0;i<particles;i++){
    points.push([floor(random(0,Sz)),floor(random(0,Sz)),true]);
}
var l=points.length-1;
var dirs=[[0,1],[1,0],[0,-1],[-1,0]];
/*functions*/
var move=function(p1){
    var mv=dirs[floor(random(0,4))];
    var temp=true;
    for(var i=l;i>=0;i--){
        if(!points[i][2]&&points[i][0]===p1[0]+mv[0]&&points[i][1]===p1[1]+mv[1]){
            temp=false;
            p1[2]=false;
            i=0;
        }
    }
    if(temp){
        p1[0]+=mv[0];
        p1[1]+=mv[1];
        if(p1[0]<0){p1[0]=0;}
        if(p1[0]>Sz){p1[0]=Sz;}
        if(p1[1]<0){p1[1]=0;}
        if(p1[1]>Sz){p1[1]=Sz;}
    }
};
/*draw*/
draw= function() {
    background(255);
    for(var i=points.length-1;i>=0;i--){
        stroke(0);
        if(points[i][2]){
            move(points[i]);
        }
        else{
            stroke(0,0,255);
        }
        point(points[i][0],points[i][1]);
    }
};

我查看了代码并发现它有点难以阅读.所以我决定用一些面向对象制作我自己的版本:

// apparently, object orientation is a lot slower than just putting the data in …

我一直在寻找一种有效的方法来处理javascript中的大型矢量列表.我创建了一套性能测试,使用不同的数据结构执行就地标量向量乘法:

AoS实施:

var vectors = [];
//
var vector;
for (var i = 0, li=vectors.length; i < li; ++i) {
    vector = vectors[i];
    vector.x = 2 * vector.x;
    vector.y = 2 * vector.y;
    vector.z = 2 * vector.z;
}

SoA实施:

var x = new Float32Array(N);
var y = new Float32Array(N);
var z = new Float32Array(N);
for (var i = 0, li=x.length; i < li; ++i) {
    x[i] = 2 * x[i];
    y[i] = 2 * y[i];
    z[i] = …

我想知道使用包含大约10万个元素(属性)的数组(或对象)在使用indexOf,slice等频繁访问它们时是否会在浏览器中导致性能或内存问题.是否有一些建议在现代浏览器中使用大数组？

我的具体情况.我有以下结构:

tack01:[平均数量为10 000的元素] ... tack0n:[平均数为10 000的元素数组]

曲目平均金额为10.

元素看起来像{id:"xa432fds",一些属性}

在运行时期间,我需要访问任何知道提供它的id的元素.

如果我在没有变换的情况下使用这个结构,我需要在所有轨道上执行搜索,并使用indexOf查找带有Id的元素.

所以我希望创建一个索引对象,它具有以下结构:indexObj = {id1:对具有id1的元素的引用,id2:对具有id2的元素的引用}

访问某个元素我只需要访问indexObj [id],这是我的案例的正确解决方案吗？

所有这些都应该在客户端执行.

我知道,因为javascript允许对象的数字键,因此技术上可能存在类似数组的对象,但为什么它们变得普遍？

也许这个想法是这些类似数组的对象不仅具有数字键,例如arguments具有callee属性,因此它们不能是适当的数组来容纳这些属性.

但是在javascript中,将数组视为对象并使用非数字键是完全有效的:

var myArguments = []; 
myArguments[0] = 0; 
myArguments['callee'] = function(){console.log('callee')};

如果对象是类似数组的,并且可以从访问函数中获益,否则它将从数组原型继承,那么使它成为类似数组的对象会有什么好处呢？

编辑:如果在我的问题中不清楚,像对象这样的数组就像arguments是具有从零开始的连续数字属性的对象,并且具有比最高数字键小1的长度属性.它也不从数组原型继承,也不提供对数组方法的访问.

我陷入困境，因为我需要选择性能最佳的选项。

我现在拥有的是一个简单的数组，例如：

var array = [
   '/index1.html',
   '/index2.html',
   '/index3.html'
];

该数组仅包含大约 60 个选项，但由于我需要按语言分隔，所以我正在考虑其他选项，例如对象文字或 JSON 格式，因此它将包含所有语言和大约 1000 个选项。

var obj = {
            'en' : {
                'title' : 'bla',
                'url':'bla bla bla'                 
            },
            'de' : {
                'title' : 'bla',
                'url':'bla bla bla'                 
            },          
        };

问题是你认为什么最适合这个？谢谢。

我正在使用Javascript vp8解码器进行工作，因此在这种情况下，对于Safari来说，需要一切都尽可能快，因为Webkit浏览器是目标平台。

需要运动矢量的结构。它几乎是一个2个字符的对象：

var test = { x:0, y:1 }
var testArray = new Uint8Array(2);

这个

test.x = (test.x | 0 + 1) | 0;
test.y = (test.y | 0 + 1) | 0;

在野生动物园中比这快得多：

testArray[0] = (testArray[0] + 1) | 0;
testArray[1] = (testArray[1] + 1) | 0;

但是其他浏览器则相反。

为什么...？

尝试jsperf：https：//jsperf.com/obj-vs-struct-7

在ios（仅桌面浏览器）上，编辑伪结构更快。

最近我有一个面试问题如下:让我们考虑我们有两个不同长度的排序数组.需要在两个数组中找到共同的元素.

var a=[1,2,3,4,5,6,7,8,9,10];
var b = [2,4,5,7,11,15];
for(var i=0;i<a.length;i++){
    for(var j=0;j<b.length;j++){
        if(a[i]==b[j]){
            console.log(a[i],b[j])
        }
    }
}

我上面写的是这样的.采访者说现在假设有2000个元素,b有3000个元素.那么你如何以更有效的方式写作？

请用示例代码解释您的答案.所以我可以更清楚地理解.

正如我们已经知道的，数组和对象之间的区别之一是：

“如果你想提供特定的键，唯一的选择是一个对象。如果你不关心键，那就是一个数组”（在这里阅读更多）

此外，根据MDN 的文档：

数组不能使用字符串作为元素索引（如在关联数组中），但必须使用整数

然而，令我惊讶的是：

> var array = ["hello"]; // Key is numeric index
> array["hi"] = "weird"; // Key is string
content structure looks like:  ["hello", hi: "weird"]

数组的内容结构看起来很奇怪。更重要的是，当我检查它返回的数组类型时true

Array.isArray(array) // true

问题：

1. 为什么会有这种行为？这似乎不一致，对吧？
2. 在幕后实际存储的数据结构是什么：作为数组或诸如对象、哈希表、链表之类的东西？
3. 这种行为是否取决于特定的 JavaScript 引擎（V8、spidermonkey等）？
4. 我应该在普通对象上使用这样的数组（键都是数字索引和字符串）吗？