Ⅰ 如何实现javascript数组中元素的上下移动
我们交换数组可以实现元素上下移动了，这个效果我们在表格或以前排序算法中都会用到，下面来看一个JavaScript下实现交换数组元素上下移动例子。
在写项目的时候，要实现一个数组记录上下移动的示例。写起来也没有没麻烦，无非是交换数组元素。最终实现代码如下，比较重要的是那个函数。
合理使用那个方法，可以实现置顶和最底的一些实现。
Ⅱ Javascript中有哪些比较成熟的机器学习算法框架
应该是没有的
除了Python以外，没有哪个语言做这种比较全面的机器学习框架
更不要说js这种主要是前端的语言
Ⅲ 如何提升JavaScript循环的运行速度
提升JavaScript循环的运行速度的方法很简单的，减少每次循环的时间复杂度. 或者提高CPU的性能.就可以了。
Ⅳ javascript算法问题
这是一个div随着滚动条移动的代码吧，你说的那3行意思如下：
1. var diff = (document.body.scrollTop + y - document.all.AdLayer.style.posTop)*.40
变量diff=（滚动条高度+DIV初始高度-DIV现在的高度）*0.4
2.var y = document.body.scrollTop + y - diff;
变量y=滚动条高度+DIV初始高度-变量diff；
3.eval("document.all." + layerName + ".style.posTop = y");
eval(...)是执行括号里面语句。这里就是设定div的新高度。
1,2行就是设置高度的一个算法而已。没什么特殊的意义，这样的算法有很多种。（PS：额`难道这就是传说中的缓冲技术？- -有空研究下）
下面是我写的一个，可能是你要的功能，你可以对比参考一下，希望对你有用：
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html>
<HEAD>
</HEAD>
<style>
.div{
position: absolute;
background-color:red;
width: 50px;
height:325px;
}
</style>
<SCRIPT LANGUAGE="JavaScript">
<!--
var ft; //初始高度
//--初始化高度--
function init(){
ft=parseInt(document.documentElement.scrollTop+(document.documentElement.clientHeight-document.getElementById("Layer").offsetHeight)/2);
document.getElementById("Layer").style.top=ft;
}
var flag=0; //只允许move()执行一次的判断变量;
var speed=5;//移动速度
var acc=100;//加速度
//--移动--
function move(){
var t=document.getElementById("Layer").style.top;
var top=parseInt(t.substring(0,t.length-2));
var myhigh=parseInt(document.documentElement.scrollTop+(document.documentElement.clientHeight-document.getElementById("Layer").offsetHeight)/2);//
if(top<myhigh-speed){ //用来缓冲
document.getElementById("Layer").style.top=top+speed; //设置新高度
}else if(top>myhigh+speed){
document.getElementById("Layer").style.top=top-speed; //设置新高度
}
setTimeout("move()",10);
}
//--防止多次执行---
function scall(){
if(flag==0){
move();
flag=1;
}
}
window.onscroll=scall;
//-->
</SCRIPT>
<BODY onload="init();">
<TABLE border="1" bordercolor="black" height="1500" width="800">
<TR>
<TD valign="top">
</TD>
</TR>
</TABLE>
<div id="Layer" class="div" style="left:850px"></div>
</BODY>
</HTML>
Ⅳ 如何精确计算JS程序运行时间，进而优化代码
一、 让代码简洁：一些简略的表达方式也会产生很好的优化
eg：x=x+1;在不影响功能的情况下可以简写为x++;
二、 变量名方法名尽量在不影响语意的情况下简单。（可以选择首字母命名）
eg：定义数组的长度可以取名为：ArrLen而不需要取为ArrayLength。
三、 关于JS的循环，循环是一种常用的流程控制。
JS提供了三种循环：for(;;)、while()、for(in)。在这三种循环中for(in)的效率最差，因为它需要查询Hash键，因此应尽量少用for(in)循环，for(;;)、while()循环的性能基本持平。当然，推荐使用for循环，如果循环变量递增或递减，不要单独对循环变量赋值，而应该使用嵌套的++或–运算符。
四、 如果需要遍历数组，应该先缓存数组长度，将数组长度放入局部变量中，避免多次查询数组长度。
因为我们常常要根据字符串、数组的长度进行循环，而通常这个长度是不变的，比如每次查询a.length，就要额外进行一个操作，而预先把var len=a.length，则就少了一次查询。
五、 尽量选用局部变量而不是全局变量。
局部变量的访问速度要比全局变量的访问速度更快，因为全局变量其实是window对象的成员，而局部变量是放在函数的栈里的。
六、 尽量少使用eval。
每次使用eval需要消耗大量时间，这时候使用JS所支持的闭包可以实现函数模板。
七、 减少对象查找
因为JavaScript的解释性，所以a.b.c.d.e，需要进行至少4次查询操作，先检查a再检查a中的b，再检查b中的c，如此往下。所以如果这样的表达式重复出现，只要可能，应该尽量少出现这样的表达式，可以利用局部变量，把它放入一个临时的地方进行查询。
八、 字符串连接。
如果是追加字符串，最好使用s+=anotherStr操作，而不是要使用s=s+anotherStr。
如果要连接多个字符串，应该少使用+=，如s+=a;s+=b;s+=c;应该写成s+=a + b + c；
而如果是收集字符串，比如多次对同一个字符串进行+=操作的话，最好使用一个缓存。怎么用呢？使用JavaScript数组来收集，最后使用join方法连接起来，如下
var buf = new Array();for(var i = 0; i < 100; i++){ buf.push(i.toString());}var all = buf.join("");
九、 类型转换
1. 把数字转换成字符串，应用"" + 1，虽然看起来比较丑一点，但事实上这个效率是最高的，性能上来说：("" +) > String() > .toString() > new String()
尽量使用编译时就能使用的内部操作要比运行时使用的用户操作要快。
String()属于内部函数，所以速度很快，而.toString()要查询原型中的函数，所以速度逊色一些，new String()用于返回一个精确的副本。
2. 浮点数转换成整型，这个更容易出错，很多人喜欢使用parseInt()，其实parseInt()是用于将字符串转换成数字，而不是浮点数和整型之间的转换，我们应该使用Math.floor()或者Math.round()。Math是内部对象，所以Math.floor()其实并没有多少查询方法和调用的时间，速度是最快的。
3. 对于自定义的对象，如果定义了toString()方法来进行类型转换的话，推荐显式调用toString()，因为内部的操作在尝试所有可能性之后，会尝试对象的toString()方法尝试能否转化为String，所以直接调用这个方法效率会更高
十、 尽量作用JSON格式来创建对象，而不是var obj=new Object()方法。
Ⅵ 什么是javascript算法
当然是用 javascript 写成的算法，用别的语言写的比如c就叫c语言算法。
Ⅶ JavaScript都有些什么运算符有什么要特别注意的我是个新手，哪个大牛帮我总结下。
你在其它主流语言中能见到的运算符，95%以上都能在JavaScript中使用。下面来看下几大类运算符：
1、 算术运算符：+，-，*，/，%
举例：45 + 44 = 89 89 - 44 = 45 9 * 3 = 27 9 / 3 = 3 86 % 10 = 6
加、减、乘、除、取余是最基本的算术运算符，几乎所有编程语言都具有这些运算符。在JavaScript语言中加、减、乘、除、取余分别用’+’， ’-’， ’*’， ’/’, ‘%’字符来表示。它们接收两个数值类型作为操作数进行相应的数学运算，并将运算结果返回。
2、 复值运算符：=
举例：total = num1+num2
赋值运算符是一个‘=’符号。当浏览器遇到赋值运算符，会先执行运算符右边的表达式，然后将其赋值给左边的变量或表达式。初学者特别要注意，这不是判断相等的运算符，而是赋值运算符。
3、 复合运算符：+=，-=，*=，/=
举例： value += 5;
“+=”运算符将相加和赋值操作合并在一起，是一个运算符，所以+=符号中间不能有空格。除了有“+=”运算符，JavaScript还提供了-=，*=和/=运算符；分别表示相减并赋值，相乘并赋值，相除并赋值。
4、 比较运算符==,===,!=,!===,>, <, >=, <=
举例： if(num1==num2) x>y, x<y, x>=y, x<=y
比较运算符比较两个对象的大小，判断是不相等，返回布尔类型的值。使用起来简单方便，但是我们需要注意如下几点：
注意1，不要混淆“=”和“==”，如
if ( num1 = num2 ) {
//除了num2为0的情况，其它情况都会执行。
}
注意2，“=”、“==”和“===”的区别
一个等号“=”是赋值运算符；两个等号“==”是相等比较的运算符(字符6和数字6会认为是相等的)；三个等号“===”是严格的相等比较运算符(字符6和数字6不会认为是相等的，即要内容和数据类型完全一致)。
5、 逻辑运算符：&&，||， ！
举例：if (x === y && m === n ) { … }
逻辑与由两个’&’组成，中间不能有空格；表示两个操作数都为true时，结果才为true。
逻辑或由两个’|’组成，与逻辑与相反，逻辑或只需操作数有一个为true，则结果为true。
逻辑非是一个感叹号，操作数为true，则结果为false，操作数为false，则结果为true。
6、 一元运算符：++，--
举例：intValue++; intValue--; ++intValue; --intValue;
自增运算符给变量加1，运算效果和intValue = intValue + 1、intValue += 1一样。自增运算符“++”是一元运算符，表示它只需要一个操作数。自增运算符又可分为前置自增和后置自增运算，即运算符++即可以放在操作数前边，也可以放在操作数后面，如前置自增++intValue和后置自增intValue++；
与自增运算符相反，自减运算符给变量减1，运算结果和intValue = intValue - 1、intValue -= 1的一样。自减运算符也是一元运算符，同样也有前置自减和后置自减的用法。
一元运算符出现的位置很重要，会影响自增运算的返回值。如前置++在计算后会返回变量增加后的值，而后置++会返回变量未增加前的值。
7、 三元运算符：? :
格式：条件表达式 ？ 表达式1 ： 表达式2;
三元运算符有疑问号?和冒号:组成。三元运算符的三个操作数如上示例，分别为条件表达式、表达式1和表达式2。当条件表达式为true时，表达式1会被执行；否则，表达式2将会被执行。这个逻辑和if-else语句很相似。
8、 位运算符：~、&、|、^、<<、>>、>>>
举例：~num, num1 & num2, num1 | num2, num1 ^ num2, -10<<2
位运算符实际就是对二进制进行与或非、左移、右移运行。
上述是从教程网站秒秒学上总结来的运算符各类，我感觉基本的运算符都囊括了，希望对你有帮助。
Ⅷ 如何使用Tween.js各类原生动画运动缓动算法
使用缓动功能，您可以加快或放慢动画的开头或结尾速度，以获得更加逼真或更加令人愉悦的效果。该技术用于修改 Flash 计算补间中的属性关键帧之间的属性值的方式。如果不使用缓动，Flash 在计算这些值时，会使对值的更改在每一帧中都一样。如果使用缓动，则可以调整对每个值的更改程度，从而实现更自然、更复杂的动画。缓动是应用于补间属性值的数学曲线。补间的最终效果是补间和缓动曲线中属性值范围组合的结果。例如，在制作汽车经过舞台的动画时，如果让汽车从停止开始缓慢加速，然后在舞台的另一端缓慢停止，则动画会显得更逼真。如果不使用缓动，汽车将从停止立刻到全速，然后在舞台的另一端立刻停止。如果使用缓动，则可以对汽车应用一个补间动画，然后使该补间缓慢开始和停止。一个未应用缓动的运动路径。请注意帧沿路径的均匀分布。已应用“停止并启动（中）”缓动的同一运动路径。请注意路径末尾附近帧的浓度，产生更逼真的汽车加速和减速。可以在属性检查器或动画编辑器中应用缓动。在属性检查器中应用的缓动将影响补间中包括的所有属性。在动画编辑器中应用的缓动可以影响补间的单个属性、一组属性或所有属性。缓动可以简单，也可以复杂。Flash 包含一系列的预设缓动，适用于简单或复杂的效果。在动画编辑器中，还可以创建自己的自定义缓动曲线。缓动的常见用法之一是在舞台上编辑运动路径并启用浮动关键帧以使每段路径中的运行速度保持一致。然后可以使用缓动在路径的两端添加更为逼真的加速或减速。在向属性曲线应用缓动曲线时，属性曲线图形区域中将显示缓动曲线的可视叠加。通过将属性曲线和缓动曲线显示在同一图形区域中，叠加使得在测试动画时了解舞台上所显示的最终补间效果更为方便。因为动画编辑器中的缓动曲线可以很复杂，所以可以使用它们在舞台上创建复杂的动画而无需在舞台上创建复杂的运动路径。除空间属性 X、Y 和 Z 外，还可以使用缓动曲线创建其他任何属性的复杂补间。
Ⅸ javaScript 算法实现
//n+nn+nnn+....
//分解成n*n+n*10*(n-1)+n*100*(n-2)+...
//比如4+44+444+4444
//则分解成4*4+40*3+400*2+4000*1
varn=3;//n的值任意大于等于1的整数
varm=1;
varsum=0;
for(i=n;i>0;i--)
{
sum+=n*i*m;
m=m*10;
}
alert(sum);
Ⅹ web前端javascript能实现什么算法或者计算
在Web开发中，JavaScript很重要，算法也很重要。下面整理了一下一些常见的算法在JavaScript下的实现，包括二分法、求字符串长度、数组去重、插入排序、选择排序、希尔排序、快速排序、冒泡法等等。仅仅是为了练手，不保证高效与美观，或许还有Bug，有时间再完善吧。
1.二分法：
function binary(items,value){
var startIndex=0,
stopIndex=items.length-1,
midlleIndex=(startIndex+stopIndex)>>>1;
while(items[middleIndex]!=value && startIndex
if(items[middleIndex]>value){
stopIndex=middleIndex-1;
}else{
startIndex=middleIndex+1;
}
middleIndex=(startIndex+stopIndex)>>>1;
}
return items[middleIndex]!=value ? false:true;
}
2.十六进制颜色值的随机生成：
function randomColor(){
var arrHex=["0","2","3","4","5","6","7","8","9","a","b","c","d"],
strHex="#",
index;
for(var i=0;i < 6; i++){
index=Math.round(Math.random()*15);
strHex+=arrHex[index];
}
return strHex;
}
一个求字符串长度的方法：
function GetBytes(str){
var len=str.length,
bytes=len;
for(var i=0;i < len;i++){
if(str.CharCodeAt>255){
bytes++;
}
}
return bytes;
}
3.js实现数组去重：
Array.protype.delRepeat=function(){
var newArray=new Array();
var len=this.length;
for(var i=0;i < len;i++){
for(var j=i+1;j < len;j++)
{
if(this[i]==this[j])
{
++i;
}
}
newArray.push(this[i]);
}
return newArray;
}
4.插入排序。所谓的插入排序，就是将序列中的第一个元素看成一个有序的子序列，然后不段向后比较交换比较交换。
function insertSort(arr){
var key;
for(var j = 1; j < arr.length ; j++){
//排好序的
var i = j - 1;
key = arr[j];
while(i >= 0 && arr[i] > key){
arr[i + 1] = arr[i];
i --;
}
arr[i + 1] = key;
}
return arr;
}
5.选择排序。其实基本的思想就是从待排序的数组中选择最小或者最大的，放在起始位置，然后从剩下的数组中选择最小或者最大的排在这公司数的后面。
function selectionSort(data)
{
var i, j, min, temp , count=data.length;
for(i = 0; i < count - 1; i++) {
/* find the minimum */
min = i;
for (j = i+1; j < count; j++)
{
if (data[j] < data[min])
{ min = j;}
}
/* swap data[i] and data[min] */
temp = data[i];
data[i] = data[min];
data[min] = temp;
}
return data;
}
6.希尔排序，也称递减增量排序算法。其实说到底也是插入排序的变种。
function shellSort(array){
var stepArr = [1750, 701, 301, 132, 57, 23, 10, 4, 1]; //
reverse()在维基上看到这个最优的步长较小数组
var i = 0;
var stepArrLength = stepArr.length;
var len = array.length;
var len2 = parseInt(len/2);
for(;i < stepArrLength; i++){
if(stepArr[i] > len2){
continue;
}
stepSort(stepArr[i]);
}
// 排序一个步长
function stepSort(step){
//console.log(step) 使用的步长统计
var i = 0, j = 0, f, tem, key;
var stepLen = len%step > 0 ? parseInt(len/step) + 1 : len/step;
for(;i < step; i++){// 依次循环列
for(j=1;/*j < stepLen && */step * j + i < len;
j++){//依次循环每列的每行
tem = f = step * j + i;
key = array[f];
while((tem-=step) >= 0){// 依次向上查找
if(array[tem] > key){
array[tem+step] = array[tem];
}else{
break;
}
}
array[tem + step ] = key;
}
}
}
return array;
}
7.快速排序。其实说到底快速排序算法就系对冒泡排序的一种改进，采用的就是算法理论中的分治递归的思想，说得明白点，它的做法就是：通过一趟排序将待排序的纪录分割成两部分，其中一部分的纪录值比另外一部分的纪录值要小，就可以继续分别对这两部分纪录进行排序;不段的递归实施上面两个操作，从而实现纪录值的排序。
function quickSort(arr,l,r){
if(l < r){
var mid=arr[parseInt((l+r)/2)],i=l-1,j=r+1;
while(true){
while(arr[++i] < mid);
while(arr[--j]>mid);
if(i>=j)break;
var temp=arr[i];
arr[i]=arr[j];
arr[j]=temp;
}
quickSort(arr,l,i-1);
quickSort(arr,j+1,r);
}
return arr;
}
8.冒泡法：
function bullSort(array){
var temp;
for(var i=0;i < array.length;i++)
{
for(var j=array.length-1;j > i;j--){
if(array[j] < array[j-1])
{
temp = array[j];
array[j]=array[j-1];
array[j-1]=temp;
}
}
}
return array;
}