javascript演算法
首先對你關注用戶體驗的精神表示支持。
僅對於你的問題補充進行一下交流：
因為用戶的錄入方式還是比較花樣繁多的，所以你的驗證js也許還會面臨一些挑戰。
比如你既然想到了backspace鍵，那麼對於delete鍵如何處理呢，如果當作非法鍵來處理的話，對於習慣小鍵盤錄入數字的人來說還是不太舒服的。
或是用戶選中文本框內一部分數字後按下backspace鍵，或是用戶調用輸入法，或是ctrl+v粘貼入文本......
當然我絕對不是在挑錯找碴，只是提一些建議：
如果需要適應這些錄入方式的話，必然要寫很多的js代碼，並且有一個問題：用戶可以禁掉javascript。所以覺得對於驗證而言，後台為主，js在前台為輔。我們的最終目的其實只有兩種，對於正確錄入值進行操作，對於錯誤值進行攔截。當然話說回來，如果你的需求確實是嚴苛的前台驗證的話，那加油吧。
以上。
❷ 如何使用javascript進行RSA/ECB/PKCS1Padding演算法加密
javascript rsa加密/java使用Cipher.getInstance("RSA/ECB/PKCS1Padding")解密
1)伺服器端獲得生成密鑰對;
2)javascript使用公鑰加密；
3)java獲得密文使用私鑰解密；
❸ 求javascript 字元串壓縮演算法
<HTML>
<HEAD>
<TITLE>Decision Helper</TITLE>
<META http-equiv=Content-Type content="text/html; charset=gb2312">
<SCRIPT LANGUAGE="JavaScript">
<!--
function Compress(strNormalString)
{
alert("壓縮前長度：" + strNormalString.length);
var strCompressedString = "";
var ht = new HashTable;
for(i = 0; i < 128; i++) {
var e = new HashTableElement;
e.key = i;
e.code = i;
ht.Insert(e);
}
var used = 128;
var intLeftOver = 0;
var intOutputCode = 0;
var pcode = 0;
var ccode = 0;
var k = 0;
for(var i=0; i<strNormalString.length; i++) {
ccode = strNormalString.charCodeAt(i);
k = (pcode << 8) | ccode;
if((intSearch = ht.Search(k)) != null) {
pcode = intSearch;
} else {
intLeftOver += 12;
intOutputCode <<= 12;
intOutputCode |= pcode;
pcode = ccode;
if(intLeftOver >= 16) {
strCompressedString += String.fromCharCode( intOutputCode >> ( intLeftOver - 16 ) );
intOutputCode &= (Math.pow(2,(intLeftOver - 16)) - 1);
intLeftOver -= 16;
}
if(used < 4096) {
used ++;
var e = new HashTableElement;
e.key = k;
e.code = used - 1;
ht.Insert(e);
}
}
}
if(pcode != 0) {
intLeftOver += 12;
intOutputCode <<= 12;
intOutputCode |= pcode;
}
if(intLeftOver >= 16) {
strCompressedString += String.fromCharCode( intOutputCode >> ( intLeftOver - 16 ) );
intOutputCode &= (Math.pow(2,(intLeftOver - 16)) - 1);
intLeftOver -= 16;
}
if( intLeftOver > 0) {
intOutputCode <<= (16 - intLeftOver);
strCompressedString += String.fromCharCode( intOutputCode );
}
alert("壓縮後長度：" + strCompressedString.length);
return strCompressedString;
}
function Decompress(strCompressedString)
{
var strNormalString = "";
var ht = new Array;
for(i = 0; i < 128; i++)
{
ht[i] = String.fromCharCode(i);
}
var used = 128;
var intLeftOver = 0;
var intOutputCode = 0;
var ccode = 0;
var pcode = 0;
var key = 0;
for(var i=0; i<strCompressedString.length; i++) {
intLeftOver += 16;
intOutputCode <<= 16;
intOutputCode |= strCompressedString.charCodeAt(i);
❹ 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;
}
❺ javascript 自動布局演算法
將整個系統看做這樣一個物理系統：質點和橡皮筋的系統；橡皮筋有個自然長度Length，當橡皮筋被拉長時產生彈力T；任意2個質點間存在反萬有引力G（簡單的說就是質量產生斥力，和物理系統相反）。當斥力和彈力平衡的時候，布局就結束了，演算法簡單描述如下：
設系統為G(V,E);
for (vi in V) {
vi.x = random ();
vi.y = random ();
}
while (未平衡) {
for (ei(vx, vy) in E) {
Fx += T(ei, vx, vy);
Ty += T(ei, vy, vx);
}
for (vi in V) {
for (vj in V) {
if (i == j) 跳過
Fi += G (vi, vj);
}
}
for (fi in F) {
vi.x = |fi| * cos(fi.angle);
vi.y = |fi| * sin(fi.angle);
}
}
其中彈力公式T(e, vi, vj)遵循胡克定律：F = Length(e) > Length ? K * (Length(e) - Length) : 0; K 為胡克常數，酌情取值
萬有引力公式G(vi, vj)遵循牛頓萬有引力定律，但方向相反:
F = -G * Mass(vi) * Mass(vj) / (Distance(vi, vj) * Distance(vi, vj)); G 為萬有引力常數，酌情取值，Mass(v)為質點v的質量，可直接去定點的邊數；Distance(vi, vj)為質點vi 和vj之間的距離，根據勾股定理可到。
系統平衡的標准：合彈力=合斥力，表現為v.x和v.y不再發生變化或震動
注意：當隨機初始化後，可能產生2個質點重疊的現象，這時2質點間的斥力可用常數替代，方向隨機。若質點無質量，可使用一個小常數替代，如.0005