JS LZW算法压缩与解压

简介: JS LZW算法压缩与解压,一个JavaScript二进制接口源码,LZW 压缩解压算法,压缩比确实不错,代码不超过200行。LZW 压缩解压* { font-size:12px}body { overflow:auto; border-style:none; backgroun...

JS LZW算法压缩与解压,一个JavaScript二进制接口源码,LZW 压缩解压算法,压缩比确实不错,代码不超过200行。

<html>
<head>
<meta http-equiv="content-type" content="text/html; charset=utf-8">
<title>LZW 压缩解压</title>
<style>
* { font-size:12px}
body { overflow:auto; border-style:none; background-color:buttonface; }
#source, #result { overflow:auto; width:100%; height:300px; }
</style>
<script>
function $(s){ return document.getElementById(s); }
window.onload = function(){
    $("source").focus();
    $("source").onkeydown = function(e){
        e = window.event || e;
        if(e.keyCode == 13 && e.ctrlKey)doit();
    }
   
    $("result").onkeydown = function(e){
        e = window.event || e;
        if(e.keyCode == 13 && e.ctrlKey)doit2();
    }
   
    $("source").value = document.getElementsByTagName("script")[0].innerHTML;
   
}
function doit(){
    $("result").value = $("chkSE").checked?("eval(("+String(lzw_decompress)+")(\""+lzw_compress($("source").value)+"\"))"):(lzw_compress($("source").value));
    $("info").innerHTML = "源:"+$("source").value.length + ",值:" + $("result").value.length + ",压缩比" + ($("result").value.length / $("source").value.length).toFixed(3);
}
function doit2(){
    $("source").value = $("chkSE").checked?(eval($("result").value.substring(4))):(lzw_decompress($("result").value));
}
function Binary(initData, p, l, bl){
    var data=initData&&initData.constructor==Array?initData.slice():[], p=p|0, l=l|0, bl=Math.max((bl||8)|0,1), mask=m(bl), _m = 0xFFFFFFFF; //数据,指针,长度,位长度,遮罩
    this.data = function(index, value){ if(!isNaN(value))data[index]=(value|0)||0; if(!isNaN(index))return data[index];else return data.slice(); }
   
    this.read = function(){
        var re;
        if(p >= l)return 0;
        if(32 - (p % 32) < bl){
            re = (((data[p>>5] & m(32 - (p%32))) << ((p+bl)%32)) | (data[(p>>5)+1]>>>(32 - ((p+bl)%32)))) & mask;
        }else{
            re = (data[p>>5] >>> (32 - (p+bl)%32)) & mask;
        }
        p+=bl;
        return re;
    }
   
    this.write = function(i){
        var i, hi, li;
        i &= mask;
        if(32 - (l % 32) < bl){
            data[l>>5] |= i >>> (bl - (32 - (l % 32)));
            data[(l>>5)+1] |= (i << (32 - ((l+bl)%32))) & _m;
        }else{
            data[l>>5] |= (i << (32 - ((l+bl)%32))) & _m;
        }
        l += bl;
    }
   
    this.eof = function(){ return p >= l; }
   
    this.reset = function(){ p=0; mask=m(bl); }
    this.resetAll = function(){ data=[]; p=0; l=0; bl=8; mask=m(bl); _m = 0xFFFFFFFF; }
   
    this.setBitLength = function(len){
        bl = Math.max(len|0, 1);
        mask=m(bl);
    }
   
    this.toHexString = function(){
        var re = [];
        for(var i=0; i<data.length; i++){
            if(data[i] < 0){
                re.push(pad((data[i]>>>16).toString(16), 4) + pad((data[i] & 0xFFFF).toString(16), 4));
            }else{
                re.push(pad(data[i].toString(16), 8));
            }
        }
        return re.join("");
    }
   
    this.toBinaryString = function(){
        var re = [];
        for(var i=0; i<data.length; i++){
            if(data[i] < 0){
                re.push(pad((data[i]>>>1).toString(2), 31) + (data[i] & 1));
            }else{
                re.push(pad(data[i].toString(2), 32));
            }
        }
        return re.join("").substring(0, l);
    }
   
    this.toCString = function(){
        var _p = p, _bl = bl, re = [];
        this.setBitLength(13);
        this.reset();
        while(p < l)re.push(C(this.read()));
        this.setBitLength(_bl);
        p = _p;
        return C(l>>>13) + C(l & m(13)) + re.join("");
    }
   
    this.fromCString = function(str){
        this.resetAll();
        this.setBitLength(13);
        for(var i=2; i<str.length; i++)this.write(D(str, i));
        l = (D(str, 0) << 13) | (D(str, 1) & m(13));
        return this;
    }
   
    this.clone = function(){ return new Binary(data, p, l, bl); }
    function m(len){ return (1<<len)-1; }
    function pad(s, len){ return (new Array(len+1)).join("0").substring(s.length) + s; }
    function C(i){ return String.fromCharCode(i + 0x4e00); }
    function D(s, i){ return s.charCodeAt(i) - 0x4e00; }
}
function lzw_compress(str){
    var b = new Binary(), code_index = -1, char_len = 8;
    var str = str.replace(/[\u0100-\uFFFF]/g, function(s){
        return "\&\#u"+pad(s.charCodeAt(0).toString(16), 4)+";";
    });
    var dic = {}, cp = [], cpi, bl = 8;
    b.setBitLength(bl);
    for(var i=0; i<(1<<char_len)+2; i++)dic[i] = ++code_index;
    cp[0] = str.charCodeAt(0);
    for(var i=1; i<str.length; i++){
        cp[1] = str.charCodeAt(i);
        cpi = (cp[0]<<16) | cp[1];
        if(dic[cpi]==undefined){
            dic[cpi] = (++code_index);
            if(cp[0] > m(bl)){ b.write(0x80); b.setBitLength(++bl); }
            b.write(cp[0]);
            cp[0] = cp[1];
        }else{
            cp[0] = dic[cpi];
        }
    }
    b.write(cp[0]);
    function pad(s, len){ return (new Array(len+1)).join("0").substring(s.length) + s; }
    function m(len){ return (1<<len)-1; }
    return b.toCString();
}

function lzw_decompress(s){var b = new function(){var d=[],p=0,l=0,L=13,k=m(L),_m=0xFFFFFFFF;this.r=function(){var r;if(32-(p%32)<L)r=(((d[p>>5]&m(32-(p%32)))<<((p+L)%32))|(d[(p>>5)+1]>>>(32-((p+L)%32))))&k;else r=(d[p>>5]>>>(32-(p+L)%32))&k;p+=L;return r;};this.w=function(i){i&=k;if(32-(l%32)<L){d[l>>5]|=i>>>(L-(32-(l%32)));d[(l>>5)+1]|=(i<<(32-((l+L)%32)))&_m;}else d[l>>5]|=(i<<(32-((l+L)%32)))&_m;l+=L;};this.e=function(){return p>=l;};this.l=function(len){L=Math.max(len|0, 1);k=m(L);};function m(len){return (1<<len)-1;}function pad(s,l){return (new Array(l+1)).join("0").substring(s.length)+s;}for(var i=2;i<s.length;i++)this.w(s.charCodeAt(i)-0x4e00);l=((s.charCodeAt(0)-0x4e00)<<13)|((s.charCodeAt(1)-0x4e00)&m(13));p=0;};var R=[],C=-1,D={},P=[],L=8;for(i=0; i<(1<<L)+2; i++)D[i]=String.fromCharCode(++C);b.l(L);P[0]=b.r();while(!b.e()){P[1]=b.r();if(P[1]==0x80){ b.l(++L); P[1]=b.r();}if(D[P[1]]==undefined)D[++C]=D[P[0]]+D[P[0]].charAt(0);else D[++C]=D[P[0]]+D[P[1]].charAt(0);R.push(D[P[0]]);P[0]=P[1];}R.push(D[P[0]]);return R.join("").replace(/\&\#u[0-9a-fA-F]{4};/g,function(w){return String.fromCharCode(parseInt(w.substring(3, 7),16));});}
function lzw_decompress_origin(str){
    var b = new Binary();
    b.fromCString(str);
    b.reset();
    var result = [], dic_code = -1;
    var dic={},cp=[], bl = 8;
    for(i=0; i<(1<<bl)+2; i++)dic[i] = String.fromCharCode(++dic_code); //init the dic
    b.setBitLength(bl);
    cp[0]=b.read();
    while(!b.eof()){
        cp[1]=b.read();
        if(cp[1] == 0x80){ b.setBitLength(++bl); cp[1]=b.read(); }
        if(dic[cp[1]]==undefined)dic[++dic_code]=dic[cp[0]]+dic[cp[0]].charAt(0);
        else dic[++dic_code]=dic[cp[0]]+dic[cp[1]].charAt(0);
        result.push(dic[cp[0]]);
        cp[0]=cp[1];
    }
    result.push(dic[cp[0]]);
    return result.join("").replace(/\&\#u[0-9a-fA-F]{4};/g,function(w){
        return String.fromCharCode(parseInt(w.substring(3, 7),16));
    });
}
</SCRIPT>
</head>
<body >
<textarea id="source"></textarea>
<textarea id="result"></textarea>
<br/>
<br/>
<input type="button" value="Compress" onclick="doit();" />
<input type="button" value="DeCompress" onclick="doit2();" />
<input type="checkbox" id="chkSE" /><label for="chkSE">压缩为自解压格式</label>
<span id="info"></span>
</body>
</html>


目录
相关文章
|
4月前
|
存储 监控 算法
局域网监控其他电脑的设备信息管理 Node.js 跳表算法
跳表通过分层索引实现O(logn)的高效查询、插入与删除,适配局域网监控中设备动态接入、IP映射及范围筛选等需求,相比传统结构更高效稳定,适用于Node.js环境下的实时设备管理。
183 9
|
6月前
|
存储 监控 JavaScript
基于布隆过滤器的 Node.js 算法在局域网电脑桌面监控设备快速校验中的应用研究
本文探讨了布隆过滤器在局域网电脑桌面监控中的应用,分析其高效空间利用率、快速查询性能及动态扩容优势,并设计了基于MAC地址的校验模型,提供Node.js实现代码,适用于设备准入控制与重复数据过滤场景。
265 0
|
4月前
|
存储 监控 JavaScript
企业上网监控系统的恶意 URL 过滤 Node.js 布隆过滤器算法
布隆过滤器以低内存、高效率特性,解决企业上网监控系统对百万级恶意URL实时检测与动态更新的难题,通过概率性判断实现毫秒级过滤,内存占用降低96%,适配大规模场景需求。
323 3
|
4月前
|
存储 监控 算法
电脑管控软件的进程优先级调度:Node.js 红黑树算法
红黑树凭借O(log n)高效插入、删除与查询特性,适配电脑管控软件对进程优先级动态调度的高并发需求。其自平衡机制保障系统稳定,低内存占用满足轻量化部署,显著优于传统数组或链表方案,是实现关键进程资源优先分配的理想选择。
268 1
|
5月前
|
运维 监控 JavaScript
基于 Node.js 图结构的局域网设备拓扑分析算法在局域网内监控软件中的应用研究
本文探讨图结构在局域网监控系统中的应用,通过Node.js实现设备拓扑建模、路径分析与故障定位,提升网络可视化、可追溯性与运维效率,结合模拟实验验证其高效性与准确性。
343 3
|
9月前
|
监控 算法 JavaScript
基于 JavaScript 图算法的局域网网络访问控制模型构建及局域网禁止上网软件的技术实现路径研究
本文探讨局域网网络访问控制软件的技术框架,将其核心功能映射为图论模型,通过节点与边表示终端设备及访问关系。以JavaScript实现DFS算法,模拟访问权限判断,优化动态策略更新与多层级访问控制。结合流量监控数据,提升网络安全响应能力,为企业自主研发提供理论支持,推动智能化演进,助力数字化管理。
231 4
|
9月前
|
监控 算法 JavaScript
公司局域网管理视域下 Node.js 图算法的深度应用研究:拓扑结构建模与流量优化策略探析
本文探讨了图论算法在公司局域网管理中的应用,针对设备互联复杂、流量调度低效及安全监控困难等问题,提出基于图论的解决方案。通过节点与边建模局域网拓扑结构,利用DFS/BFS实现设备快速发现,Dijkstra算法优化流量路径,社区检测算法识别安全风险。结合WorkWin软件实例,展示了算法在设备管理、流量调度与安全监控中的价值,为智能化局域网管理提供了理论与实践指导。
244 3
|
9月前
|
存储 监控 算法
公司内部网络监控中的二叉搜索树算法:基于 Node.js 的实时设备状态管理
在数字化办公生态系统中,公司内部网络监控已成为企业信息安全管理体系的核心构成要素。随着局域网内终端设备数量呈指数级增长,实现设备状态的实时追踪与异常节点的快速定位,已成为亟待解决的关键技术难题。传统线性数据结构在处理动态更新的设备信息时,存在检索效率低下的固有缺陷;而树形数据结构因其天然的分层特性与高效的检索机制,逐渐成为网络监控领域的研究热点。本文以二叉搜索树(Binary Search Tree, BST)作为研究对象,系统探讨其在公司内部网络监控场景中的应用机制,并基于 Node.js 平台构建一套具备实时更新与快速查询功能的设备状态管理算法框架。
329 3
|
JavaScript Java 测试技术
基于springboot+vue.js+uniapp的客户关系管理系统附带文章源码部署视频讲解等
基于springboot+vue.js+uniapp的客户关系管理系统附带文章源码部署视频讲解等
352 2
|
JavaScript 前端开发
JavaScript中的原型 保姆级文章一文搞懂
本文详细解析了JavaScript中的原型概念,从构造函数、原型对象、`__proto__`属性、`constructor`属性到原型链,层层递进地解释了JavaScript如何通过原型实现继承机制。适合初学者深入理解JS面向对象编程的核心原理。
279 1
JavaScript中的原型 保姆级文章一文搞懂

热门文章

最新文章