分享我常用的Javascript工具函数

//----- 获得json数据的字符串格式 ---------------
Object.prototype.toString=function(){
var rtn="{";
for(var i in this){
rtn+=i+":"+this[i]+",";
}
rtn=rtn.substring(0,rtn.length-1);
rtn+="}";
return rtn;
}

Array.prototype.toString=function (){
var rtn="[";
for(var i in this){
rtn+=this[i]+",";
}
rtn=rtn.substring(0,rtn.length-1)+"]";
return rtn;
}
//-------------- Array添加indexOf方法 ------------
//*** 返回某个元素在数组中的索引值 ***
Array.prototype.indexOf=function(item){
for(var i=0;i<this.length;i++){
if(this[i]==item) return i;
}
return -1;
};

//----------------- swDisplay(o)  -----------
//*** 函数 切换元素的显示和隐藏 ***
function swDisplay(o){
var dv=(o.currentStyle||window.getComputedStyle(o,null)).display;
switch (dv){
case "":
o.style.display="none";
break;
case "block":
o.style.display="none";
break;
case "inline":
o.style.display="none";
break;
case "none":
o.style.display="block";
break;
default:
break;
}
}

function swDisplayBetter(evObj,evType,targetObj){ // swDisplayBetter($('evDiv'),'click',$('tDiv'))
//evObj[evType]=function(){ swDisplay(targetObj);}
if(document.all){
evObj.attachEvent('on'+evType,function(){ swDisplay(targetObj);});
}else{
evObj.addEventListener(evType,function(){ swDisplay(targetObj);},false);
}
}

//-----------------  getCookie(cname), setCookie(cname,cvalue,expiresDays)  --------------------
//*** cookies的读写函数  ***
// 读取cookie  getCookie(cookiename)
function getCookie(Cname){
var start=document.cookie.indexOf(Cname+'=');
if(start<0){
return null;
}
else{
start+=Cname.length+1; //Cname=后面
//fname=pan;
var endPos=(document.cookie+';').indexOf(';',start);// ;号前面
return   document.cookie.substring(start,endPos);
}
}
//写入cookies
function setCookie(Cname,Cvalue,expiresDays){ //cookies名称 cookies值 几天过期
var expires=new Date();
expires.setTime(expires.getTime()+expiresDays*24*60*60*1000);
document.cookie=Cname+'='+Cvalue+';expires='+expires.toGMTString(); //增加cookies 不会覆盖旧的cookies
//alert(document.cookie);
}

//----------------- getElementsByClassName ------------------
//*** 根据class获取元素 ***
function getElementsByClassName(clsName,root,tag){
if(root){ //root为id或者父节点
root=typeof root==='string'?document.getElementById(root):root;
}else{
root=document;
}
var nodeArr=[];
var tag= tag || "*"; //查找某种标签的class 还是所有标签的class
var subEles=root.getElementsByTagName(tag);
for(var i=0,l=subEles.length;i<l;i++){
if(subEles[i].className.indexOf(clsName)>=0){nodeArr.push(subEles[i])}
}
return nodeArr;
}

example:
var mcNodes=getElementsByClassName("mc");
var mcNodes=getElementsByClassName("mc","p1");
var mcNodes=getElementsByClassName("mc",null,"p");
var mcNodes=getElementsByClassName("mc","p1","b");

//---------------------- addClass(obj,itsClass) ------------------------------

function addClass(obj,itsClass){
if (obj.className.toString()=="") { //若没有设置class
obj.className=itsClass;
}
else if(obj.className.indexOf(itsClass)<0){
obj.className+=" "+itsClass;
}

}

function addClass(obj,clsName){
if(obj.className.indexOf(clsName)<0)
obj.className=obj.className==""?clsName:(obj.className+" "+clsName);
}

利用条件运算符的结合性会更简洁一点

function addClass(obj,clsName){
var re=new RegExp("(\\s+"+clsName+"| ^"+clsName+"\\s+)","g");
var re1= new RegExp("^"+clsName +"$","g");
var ifhas = re.test(obj.className) || re1.test(obj.className);
obj.className+=obj.className==''?clsName:ifhas?'':' '+clsName;
}

//---------------------- removeClass(obj,itsClass) ------------------------------

//~~算法逻辑是对的 显得繁琐了点 建议用正则方式 简单明了 replace()支持正则 和 函数参数
function removeClass(obj,itsClass){
if(obj.className.toString().indexOf(" ")>=0){//若包含空格 即class 中定义多个类名
if(obj.className.indexOf(itsClass)>=0) obj.className=obj.className.replace(" "+itsClass,"");
}
else {
if(obj.className.indexOf(itsClass)>=0) {obj.className=obj.className.replace(itsClass,"");}
}
}

function removeClass(obj,clsName){
var re=new RegExp("(\\s+"+clsName+"| ^"+clsName+"\\s+)","g");
var re1= new RegExp("^"+clsName +"$","g");
obj.className=re1.test(obj.className) ? "" : obj.className.replace(re,"");
}

//---------------------- setMoverMout(obj,itsClass) ----------------------------
//*** 设置元素的onmouseover onmousout ***
//~~~结合addClass  removeClass函数使用

function setMoverMout(obj,itsClass){
obj.onmouseover=function(){addClass(this,itsClass);};
obj.onmouseout=function(){removeClass(this,itsClass);};
//上下文环境为obj，所以匿名函数内 this指向obj,this作为实参传入addClass函数
}

//-------------  each(eles,fn) -----------------------
//*** 遍历数组元素，每个元素作为参数传入fn并执行 ***
function each(eles,fn){
for(var i=0;i<eles.length;i++){
fn(eles[i]); //fn接受一个dom元素作为参数 或者 fn(domEle,index,eles){}
}
}

//------------------------------------ addEvent ----------------------------------
//obj需要绑定事件的元素, type 事件类型, func 事件处理函数
//注意在事件处理函数 func 内部，不能用this来引用事件源对象，this指向了window ;需要用event.srcElement||event.target获取事件源对象
function addEvent(obj,type,func){
if(document.all){ //for ie
obj.attachEvent( "on"+type, function(e){func.apply(obj,arguments);} );
}else{ //for FF
obj.addEventListener( type, function(e){func.apply(obj,arguments)}, false ); //可以用fn.apply绑定fn内this的指向
}
}

//....... Example .............

function hi(){alert("nice to meet you");}

addEvent($("hi"),"click",hi);

function addBg(event){(event.srcElement||event.target).style.background="#c9a47a";}
function removeBg(event){(event.srcElement||event.target).style.background="none";}

addEvent($("hi"),"mouseover",addBg);
addEvent($("hi"),"mouseout",removeBg);

//------------------------ on(node,eventType,handler,scope) ---------------------
//*** 工具函数 给对象的事件绑定事件处理函数 ***
// on函数比addEvent函数多了个 scope参数，更加灵活一点
function on(node,eventType,handler,scope){
node=typeof node=="string" ? document.getElementById(node) : node;
if(!!!node) { alert('没找到对应的dom元素'); return;}
scope=scope || node;
if(document.all){  // for ie
node.attachEvent("on"+eventType,function(){
handler.apply(scope,arguments)
// handler一般在全局环境定义，this指向window,
// 这里指定事件处理函数的上下文对象为事件源元素或 你希望的元素
// 上下文对象 和 arguments 传入handler函数并执行
});
} else { //for firefox
node.addEventListener(eventType,function(){
handler.apply(scope,arguments)
},false);
//firefox 可以在捕获和冒泡阶段触发事件处理函数 ,false表示不在捕获阶段触发事件
}
}

//-------------------------------- getStyle() ------------------------
//获取元素的当前样式或计算样式

function getStyle(o,styleName){
return (o.currentStyle||window.getComputedStyle(o,null))[styleName];
}

//------------------------- nobubble() ----------------------------
//阻止事件冒泡
function nobubble(event){
//event 事件对象作为参数传入
if(document.all){
event.cancelBubble=true;
}else{
event.stopPropagation();
}
}

//----------------------- String.prototype.replaceAll(fnd,rep) ------------
//String类 扩展方法 字符串查找替换
String.prototype.replaceAll(fnd,rep){
return this.split(fnd).join(rep);
}

//--------------------- String.prototype.trim() -----------------------
//String类扩展方法trim 删除前后空格
String.prototype.trim=function(){
return this.replace(/(^\s*)|(\s*$)/g,"");
};

//---------------- $tag(tag,root) ---------------------
//*** 根据tagname获取元素的全局函数 document.getElemntsByTagName(tag)的简写版
function $tag(tag,root){return (root||document).getElementsByTagName(tag);}

//------------------ $(id) ---------------
//*** document.getElementById(id) 的简写版 ***
function $(id){return document.getElementById(id);}

//------------------- bindMouseWheelEvent(obj,handler) ----------------------
//*** 给对象绑定鼠标滑轮事件 兼容各浏览器的方法
//绑定滑轮事件 兼容各浏览器
//绑定滑轮事件 兼容各浏览器
function bindWheelEvent(obj,handler){
if(document.addEventListener){ //ie以外的主流浏览器都支持
//只有firefox有效  其他ie和非ie主流浏览器执行 dom.onwheelscroll=fn
obj.addEventListener('DOMMouseScroll',handler,false);
}
obj.onmousewheel=handler;
}

//----- example: ---------

each(colorTxts,function(obj){bindWheelEvent(obj,colorValChg);});
// 滚动鼠标滑轮的事件处理函数
function colorValChg(e){
// alert(this.id); this指向事件源元素

//获取event对象
e=e||window.event;
var data=(e.wheelDelta/24)||(e.detail/-1);//ie9 chrome up 24 down -24; firefox up -1 down 1;
var colorV=parseInt(this.value,10)+data;
colorV=(colorV>255||colorV<0)?0:colorV;
this.value=colorV+'';
var k,m,n;
k=colorTxts[0].value;
m=colorTxts[1].value;
n=colorTxts[2].value;
$('showColor').style.background='rgb('+k+','+m+','+n+')';
}

//---------------------------- extend(subCls,supperCls,px)---------------------------
//*** 继承

function extend(subCls,supperCls,px){ //subCls子类 supperCls父类 px对象 子类需要扩展的属性集合
if(!subCls || !supperCls) throw Error ('extend error');
var F=function(){};
F.prototype=supperCls.prototype;
subCls.prototype=new F(); //通过实例化获得新对象，新对象和supperCls.prototype对象 地址不同 属性集合相似
subCls.prototype.constructor=subCls;
subCls.supperClass=supperCls.prototype;
if(px){
for(var i in px){
if(px.hasOwnProperty(k)) subCls.prototype[k]=px[k];
}
}
return subCls;
}

//---------------------------- objAttr2arr(obj) ----------------------
//*** 把对象的属性赋值到数组中 并返回该数组 ***
function objAttr2arr(obj){
var arr=[],i=0;
for(arr[i++] in obj) /* empty statement */ ;
return arr;
}

//--------------------- classOf(obj) -----------------
//*** 返回任意对象的类属性 对象的类型信息 ,正确返回js内置对象的对象类型***
function classOf(o){
if(o===null) return 'null';
if(o===undefined) return 'undefined';
return Object.prototype.toString.call(o).slice(8,-1);
}
classOf([]);
classOf({});
classOf("hi");
classOf(function(){});
//------------------ Array.prototype.distinct ------------
//*** 扩展数组的方法，返回数组中不相同的元素
Array.prototype.distinct=function(){
var oArrVals={};
var arrRtn=[];
for(var i=0,len=this.length;i<len;i++){
if(oArrVals[this[i]]) continue;
oArrVals[this[i]]=i;
arrRtn.push(this[i]);
}
return arrRtn;
};
//------------------ Function.prototype.bind -------------
//*** 扩展函数类的方法，用闭包模拟ES5的bind方法，将函数绑定到特定的上下文对象和绑定部分实参
Function.prototype.bind=function(o /*,arg1,arg2...*/){
var self=this,boundArgs=arguments; // arguments[0]=this, arguments[1]=arg1,...
return function(){ //这是一个闭包
var args=[],i;
for(i=1;i<boundArgs.length;i++){
args.push(boundArgs[i])
}
for(i=0;i<arguments.length;i++){
args.push(arguments[i]);
}
return self.apply(o,args);
}
}
//---------------------- array(args,n) ----------------------
//*** 把类数组对象转换为真正的数组对象
function array(args,n){ //args为类数组对象 , n 可选参数 表示从哪个索引开始转换
return Array.prototype.slice.call(args,n||0);
}

//------------------------ JsonStringfy(o) --------------------
//*** json对象序列化 需要配合classOf函数获取类属性
function JsonStringfy(o){
if(classOf(o)==='Array'){
var s='[',n=0;
for(var i=0;i<o.length;i++){
if(n++) s+=',';
if(classOf(o[i])==='Array' || classOf(o[i])==='Object'){
s+=JsonStringfy(o[i]);
}else{
s+=o[i].toString();
}
}
return s+=']';
}
if(classOf(o)==='Object'){
var s='{',m=0;
for(var p in o){
if(!o.hasOwnProperty(p)) continue;
if(m++) s+=',';
if(classOf(o[p])==='Array' || classOf(o[p])==='Object'){
s+=p+':'+JsonStringfy(o[p]);
}else{
s+=p+':'+o[p];
}
}
return s+='}';
}
alert('not an Array or Object');
return;
}
var mobj={a:1,b:2,c:3,d:[4,5,6]};
var marr=['a','b','c',mobj];
alert(JsonStringfy(mobj));
alert(JsonStringfy(marr));

//--------------------------- parseXML(xmlfile) ------------------
//***解析xml文件的跨浏览器实现
function parseXML(xmlFile){
try{ //ie
var xmlDoc=new ActiveXObject("Microsoft.XMLDOM");
}
catch(e){ //firefox,safari,opera
try{
var xmlDoc=document.implementation.createDocument("","",null);
}
catch(e){
alert(e.message);
return;
}
}
xmlDoc.async=false;
xmlDoc.load(xmlFile);
}

//---------------------------- parseXMLString(xmlStr) -------------------
//*** 解析xml字符串的跨浏览器实现
function parseXMLString(xmlStr){
try{ //ie
var xmlDoc=new ActiveXObject("Microsoft.XMLDOM");
xmlDoc.async=false;
xmlDoc.loadXML(xmlStr);

}
catch(e){
try{ //firefox,opera,chrome
var parser=new DOMParser();
var xmlDoc=parser.parseFromString(xmlStr,"text/xml");
}
catch(e){
alert(e.message);
return;
}
}
return xmlDoc;
}

//---------------------------------- sendAjax(url) ---------------------
//*** 发送ajax请求的跨浏览器实现
var xmlhttp; //因为stateChange函数需要xmlhttp对象 所以定义为全局的。
function sendAjax(url){
if(window.XMLHttpRequest){ //for new browser include ie 7
xmlhttp=new XMLHttpRequest();
}
else if(window.ActiveXObject){ //for ie5/6
xmlhttp=new ActiveXObject("Microsoft.XMLHTTP");
}
if(xmlhttp!=null){
xmlhttp.onreadystatechange=stateChange;
xmlhttp.open("GET",url,true);
xmlhttp.send(null);
}else{
alert("your browser does not support XMLHTTP");
}
}

function stateChange(){
if(xmlhttp.readyState==4){ //loaded
if(xmlhttp.status==200){// ok
// our code here
}
}
}

//------------------ Array.prototype.filter(fn)---------------
//*** 返回能在fn中返回true的元素组成的新数组
Array.prototype.filter=function(fn){ //高阶函数filter
var a=[];
for(var i=0;i<this.length;i++){
if(fn(this[i])) a.push(this[i]);
}
}

example fn:
function isOdd(n){
return parseInt(n)%2===1;
}

map each filter

//-----------------------------------------------------
//给一个函数绑定上下文对象和部分参数
proxy: function( fn, context ) {
var args, proxy, tmp;

if ( typeof context === "string" ) {//若参数2是字符串 则修正参数
tmp = fn[ context ];
context = fn; //参数1作为context,参数1[参数2]作为fn 形如：proxy(Array.prototype,'slice')
fn = tmp;
}

if ( !jQuery.isFunction( fn ) ) {//参数1不是函数 则返回undefined
return undefined;
}

// 模仿 bind 的原理
args = Array.prototype.slice.call( arguments, 2 ); //proxy函数第3个参数开始的参数列表
proxy = function() {//闭包 外部函数proxy的参数列表+闭包的参数列表形成新的args数组作为fn的参数
return fn.apply( context || this, args.concat( Array.prototype.slice.call( arguments ) ) );
};

// Set the guid of unique handler to the same of original handler, so it can be removed
proxy.guid = fn.guid = fn.guid || jQuery.guid++;

return proxy;
},

//----- 参考jQuery的proxy方法，可给事件处理函数 提供附加的数据 ----
//** 事件处理函数以闭包的形式返回，父函数给其绑定所需数据
function handlerBindData(fn){
if(typeof fn !== 'function') return fn; //fn非函数 则直接返回fn 什么也不做
var args = Array.prototype.slice.call(arguments, 1); //第2个参数开始的参数数组
var _fn = function(){
fn.apply(this, Array.prototype.concat.call(Array.prototype.slice.call(arguments), args));
}
return _fn;
}

function menuText(ev){
alert((ev.srcElement || ev.target).innerHTML);
if(arguments[1]) alert('i am the first one');
}

var menuTextWithData = handlerBindData(menuText, 'first');//绑定的参数+闭包的参数为实际的参数列表
$('firstLi').onclick = function(ev){menuTextWithData(ev)};

//------------------- fn.bind(oContent) --------------
//** 为函数绑定上下文对象，其实和上面的 handlerBindData一样的原理，都是返回一个绑定部分参数的闭包

Function.prototype.bind = function(oContext){
var that = this;
return function(){ that.apply(oContext, arguments); };
};
function test(){ alert(this.hi);}
var k = {'hi':'good'};
var test_ = test.bind(k); //封装原函数的一个闭包,绑定了上下文对象

//----------------- methodize(fn) ---------------------------------

** 借鉴Prototype的思想，把工具函数转化为方法函数，用面向对象的方式调用，从而避免了命名空间冲
突的问题。可以获取DOM元素时进行扩展，也可以直接扩展到DOM元素原型对象上，成为额外的固有方法
Function.prototype.methodize = function(fn){
return function(){ //返回一个包装原函数的闭包，闭包中绑定执行上下文，且让this成为第
一个形参的实参传入
var args=Array.prototype.slice.call(arguments); //获取其他参数
args.unshift(this); //让this作为第一个形参的值
fn.apply(this, args);//在指定上下文和绑定部分形参的情形下执行原有函数
}
}

~~~example:

function addClass(obj, cls){
if(typeof obj ==='string') obj = document.getElementById(obj);
obj.className+=obj.className.indexOf(cls)>=0?'':obj.className===''? cls : ' '+cls;
alert(obj.className);
}
window.onload = function(){
//addClass('test', 'hover');
var oTest = $id('test');
oTest.addClass('hover');
}

$id = function(id){
var e = document.getElementById(id);
e.addClass = addClass.methodize();
return e;
};

//------------------- url后面的参数转换为json对象 -----------------------

function urlPara2json(){
if(location.href.indexOf('?')==-1) return null;
var obj;
var paraStr = location.href.substring(location.href.indexOf('?')+1);
var arr = paraStr.split('&');

function turn2pro(s){
obj = obj || {};
var arrPro = s.split('=');
if(obj[arrPro[0] ]){
if(typeof obj[arrPro[0] ] =='string'){ obj[arrPro[0] ] = [ obj[arrPro[0]] ]; }
obj[arrPro[0] ].push(arrPro[1]);
}else{
obj[arrPro[0] ] = arrPro[1];
}
}

for(var i = 0, len=arr.length; i<len; i++){
turn2pro(arr[i]);
}
console.log(obj);
return obj;
}

//------------------- 获取元素相对页面的offset -----------------------
function pageOffset(ele){
var x=0,y=0;
while(p = ele.offsetParent){
x+=ele.offsetLeft;
y+=ele.offsetTop;
ele = p;
}
return {"x":x,"y":y};
}

//------------------------ onDomLoaded ---------------------
/* 当dom加载完成时 执行回调函数 */
function onDomLoaded(fn){
if ( document.addEventListener ) {// for:firefox,opera, chrome
document.addEventListener( "DOMContentLoaded", fn, false );
} else if ( document.attachEvent ) {// for:ie
document.attachEvent( "onreadystatechange", function(){ if(document.readyState === 'complete') fn(); } );
}
}

//------------------------ hasClass ------------------------

/* 判断元素是否具有给定class名 */

function hasClass(obj,cls){
　　return (new RegExp("(^|\\s+)"+cls+"(\\s+|$)",'i') ).test(obj.className);
}

or

function hasClass(obj,cls){
return obj.className.split(' ').indexOf(cls)>=0 ;
}

//----------------------- inherits -------------------------
//****inherits method ~~~实际是在函数内封装了组合继承的实现方法
function inherits(superCls, methodObj){
function foo(){
superCls.apply(this, arguments);
}
function bar(){}
bar.prototype = superCls.prototype;
foo.prototype = new bar();
for(var k in methodObj ){
if(methodObj.hasOwnProperty(k)){
foo.prototype[k] = methodObj[k];
}
}
return foo.prototype.constructor = foo;
// return foo;
}

var subCls = inherits(superCls, {sing:function(){ console.log('i can sing

a song'); } });
var sub = new subCls('nice to meet you');

function superCls(w){
this.hi=w;
this.kind="fn";
}
superCls.prototype.say = function(){ alert(this.hi);}

//---------------------- JSON.parse, JSON.stringify --------------

//*** JSON序列化和反序列化 ie8+ ,现代浏览器支持的原生方法

作用：这个函数的作用主要是为了系列化对象的。
可能有些人对系列化这个词过敏，我的理解很简单。就是说把原来是对象的类型转换成字符串类型（或者更确切的说是json类型的）。就这么简单。打个比方说，你有一个类，那么你可以通过这个方法转换成相应的json类型的。很简单吧。
接着看。
语法：
JSON.stringify(value [, replacer] [, space])
value：是必须要的字段。就是你输入的对象，比如数组啊，类啊等等。
replacer：这个是可选的。它又分为2种方式，一种是方法，第二种是数组。
情况一：我们先说数据，通过我们后面的实验可以知道，它是和第一个有关系的。一般来说，我们系列化后的结果是通过键值对来进行表示的。
比如说：
name:"lan",age:25
这种形式。
所以，如果这种形式的话，如果第二个的值在第一个存在，那么的话就以第二个的值做key，第一个值为value进行表示，如果不存在，sorry，忽略。【是不是有点抽象，我也这么觉得，不过你等一下看实验 就OK了。。呼呼。】
情况二：如果是方法，那很简单，就是说把系列化后的每一个对象（记住 是每一个）传进方法里面进行处理。
space：很好理解，用什么来做分隔符的。
1.如果省略的话，那么显示出来的值 就没有分隔符。直接输出来
2.如果是一个数字的话，那么它就定义缩进几个字符，当然 如果大于10 ，则最大值为10.
3.如果是一些转义字符，比如“\t”，表示回车，那么它每行一个回车。
4.如果仅仅是字符串，OK，就在每行输出值的时候把这些字符串附加上去就OK。当然，最大长度也是10个字符。
开始用实例说明；
1.只有一个参数的情况下：

复制代码代码如下:

var student = new Object();
student.name = "Lanny";
student.age = "25";
student.location = "China";
var json = JSON.stringify(student);
alert(student);

结果如下:



有些人可能会怀疑JSON.stringify的作用，OK。那假如，我们不要这个函数。代码下面的样子：

复制代码代码如下:

var student = new Object();
student.name = "Lanny";
student.age = "25";
student.location = "China";

// var json = JSON.stringify(student);
alert(student);

　恭喜你 得到的结果是：



没骗你吧，继续。
2.第二个参数存在，并且第二个参数还是function的时候

复制代码代码如下:

var students = new Array() ;
students[0] = "Lanny";
students[1] = "dong";
students[2] = "I love you";
var json = JSON.stringify(students,switchUpper);
function switchUpper(key, value) {
return value.toString().toUpperCase();
}
alert(json);

　　　　　　　　//var json = JSON.stringify(students, function (key,value) {

　　　　　　　　//return value.toString().toUpperCase();

　　　　　　　//});

　　　　上面的方法也可以换成下面的，2个都是一样，只是写法有那么一点点的不一样而已。
　得到结果如下：



3.第二个参数存在，并且第二个参数不是function，而是数组的时候。
3.1 【误区】如果第一个参数是数组，第二个参数也是数组的话，只显示第一个参数的值。
比如：

复制代码代码如下:

var students = new Array() ;
students[0] = "Lanny";
students[1] = "dong";
students[2] = "I love you";
var stu = new Array();
stu[0] = "1";
stu[1] = "2";
var json = JSON.stringify(students,stu);
alert(json);

　sorry 得到的结果就是：



第二个被忽略了，只是第一个被系列化了。

3.2 如果第一个是对象（这里说的对象就像在C#里面可以进行new的），第二个是数组的。

那么如果第二个的value在第一个存在，那么的话就以第二个的值做key，第一个值为value进行表示

复制代码代码如下:

var student = new Object();
student.qq = "5485891512";
student.name = "Lanny";
student.age = 25;

var stu = new Array();
stu[0] = "qq";
stu[1] = "age";
stu[2] = "Hi";//这个student对象里不存在。

var json = JSON.stringify(student,stu);
alert(json);

　得到的结果如下：



因为stu[2] = "Hi";这个Hi 在第一个找不到，所以就不进行显示了。

4.第三个参数

4.1.如果省略的话，那么显示出来的值 就没有分隔符。直接输出来

比如：

复制代码代码如下:

var student = new Object();
student.qq = "5485891512";
student.name = "Lanny";
student.age = 25;

var stu = new Array();
stu[0] = "qq";
stu[1] = "age";
stu[2] = "Hi";

var json = JSON.stringify(student,stu);
alert(json);

　输出的就是：



4.2.如果是一个数字的话，那么它就定义缩进几个字符，当然 如果大于10 ，则最大值为10.

复制代码代码如下:

var student = new Object();
student.qq = "5485891512";
student.name = "Lanny";
student.age = 25;

var stu = new Array();
stu[0] = "qq";
stu[1] = "age";
stu[2] = "Hi";

var json = JSON.stringify(student,stu,100);//注意这里的100
alert(json);

那么得到的是：



空开来了10个字符。

4.3.如果是一些转义字符，比如“\t”，表示回车，那么它每行一个回车。

也是一样。

4.4.如果仅仅是字符串，OK，就在每行输出值的时候把这些字符串附加上去就OK。当然，最大长度也是10个字符。

如果是var json = JSON.stringify(student,stu,“HaiKou”);//



就这样吧 。good night。