js高级应用

function getByteLen(val) { var len = 0; for (var i = 0; i < val.length; i++) { var a = val.charAt(i); if (a.match(/[^\x00-\xff]/ig) != null) { len += 2; } else { len += 1; } } return len;}

function getByteLen(val) { var len = 0; for (var i = 0; i < val.length; i++) { var length = val.charCodeAt(i); if(length>=0&&length<=128) { len += 1; } else { len += 2; } } return len;}

<!-- Bootstrap core JavaScript -->
<script src="/js/jquery/jquery-1.8.3.min.js"></script>
<script src="/js/bootstrap/js/bootstrap.min.js"></script>
<script src="/js/framework/jquery.menu.js"></script>
<script src="/js/framework/jquery.menu.js"></script>
<script src="/portal/common/js/jquery-easyui/jquery.easyui.min.js"></script>
<script type="text/javascript">
var msg = [];
$("script").each(function(){
var item = $(this);
$("script").each(function(){
var innerItem = $(this);
if(item.attr("src")==innerItem.attr("src")){
var count = $("script[src*='"+item.attr("src")+"']").size() || 0;
if(count>1){
var itemInfo = item.attr("src")+":"+count+"\n";
if($.inArray(itemInfo,msg)<0){
msg.push(itemInfo);
}
}
}
});
});
if(msg!=""){
$.messager.alert("提示",msg);
}
</script>

var a=[1,2,3,5];
alert(Math.max.apply(null, a));//最大值
alert(Math.min.apply(null, a));//最小值多维数组
var a=[1,2,3,[5,6],[1,4,8]];
var ta=a.join(",").split(",");//转化为一维数组
alert(Math.max.apply(null,ta));//最大值
alert(Math.min.apply(null,ta));//最小值使用链式
Array.prototype.max = function() {
return Math.max.apply({},this)}
Array.prototype.min = function() {
return Math.min.apply({},this)}
[1, 2, 3].max()// => 3
[1, 2, 3].min()// => 1使用方法[1,2,3].max()
Array.max = function(array) {
return Math.max.apply(Math, array);};Array.min = function(array) {
return Math.min.apply(Math, array);};

js apply和js call方法总是让初学者困惑，下文就apply和call的区别，什么情况下用apply,什么情况下用call、apply的巧妙用法来阐述js apply和js call方法的详细使用方法。主要我是要解决一下几个问题:1. apply和call的区别在哪里2. 什么情况下用apply,什么情况下用call3. apply的其他巧妙用法（一般在什么情况下可以使用apply）apply:方法能劫持另外一个对象的方法，继承另外一个对象的属性.Function.apply(obj,args)方法能接收两个参数：obj：这个对象将代替Function类里this对象
args：这个是数组，它将作为参数传给Function（args-->arguments）call:和apply的意思一样,只不过是参数列表不一样.Function.call(obj,[param1[,param2[,…[,paramN]]]])obj：这个对象将代替Function类里this对象
params：这个是一个参数列表1. apply示例:js apply和js call方法详解分析: Person.apply(this,arguments);this:在创建对象在这个时候代表的是studentarguments:是一个数组,也就是[“zhangsan”,”21”,”一年级”];也就是通俗一点讲就是:用student去执行Person这个类里面的内容,在Person这个类里面存在this.name等之类的语句,这样就将属性创建到了student对象里面2. call示例在Studen函数里面可以将apply中修改成如下:Person.call(this,name,age);这样就ok了3.什么情况下用apply,什么情况下用call在给对象参数的情况下,如果参数的形式是数组的时候,比如apply示例里面传递了参数arguments,这个参数是数组类型,并且在调用Person的时候参数的列表是对应一致的(也就是Person和Student的参数列表前两位是一致的) 就可以采用 apply , 如果我的Person的参数列表是这样的(age,name),而Student的参数列表是(name,age,grade),这样就可以用call来实现了,也就是直接指定参数列表对应值的位置(Person.call(this,age,name,grade));4. apply的一些其他巧妙用法细心的人可能已经察觉到,在我调用apply方法的时候,第一个参数是对象(this), 第二个参数是一个数组集合, 在调用Person的时候,他需要的不是一个数组,但是为什么他给我一个数组我仍然可以将数组解析为一个一个的参数,这个就是apply的一个巧妙的用处,可以将一个数组默认的转换为一个参数列表([param1,param2,param3] 转换为 param1,param2,param3) 这个如果让我们用程序来实现将数组的每一个项,来装换为参数的列表,可能都得费一会功夫,借助apply的这点特性,所以就有了以下高效率的方法:a) Math.max 可以实现得到数组中最大的一项因为Math.max 参数里面不支持Math.max([param1,param2]) 也就是数组但是它支持Math.max(param1,param2,param3…),所以可以根据刚才apply的那个特点来解决 var max=Math.max.apply(null,array),这样轻易的可以得到一个数组中最大的一项(apply会将一个数组装换为一个参数接一个参数的传递给方法)这块在调用的时候第一个参数给了一个null,这个是因为没有对象去调用这个方法,我只需要用这个方法帮我运算,得到返回的结果就行,.所以直接传递了一个null过去b) Math.min 可以实现得到数组中最小的一项同样和 max是一个思想 var min=Math.min.apply(null,array);c) Array.prototype.push 可以实现两个数组合并同样push方法没有提供push一个数组,但是它提供了push(param1,param,…paramN) 所以同样也可以通过apply来装换一下这个数组,即:vararr1=new Array("1","2","3");
vararr2=new Array("4","5","6");
Array.prototype.push.apply(arr1,arr2);
也可以这样理解,arr1调用了push方法,参数是通过apply将数组装换为参数列表的集合.通常在什么情况下,可以使用apply类似Math.min等之类的特殊用法:一般在目标函数只需要n个参数列表,而不接收一个数组的形式（[param1[,param2[,…[,paramN]]]]）,可以通过apply的方式巧妙地解决这个问题!

(function(win) {
var Map = function() {
this.count = 0;
this.entrySet = {};
}; var proto = Map.prototype; proto.size = function() {
return this.count;
}; proto.isEmpty = function() {
return this.count == 0;
}; proto.containsKey = function(key) {
if (this.isEmpty()) {
return false;
}
for ( var prop in this.entrySet) {
if (prop == key) {
return true;
}
} return false;
}; proto.containsValue = function(value) {
if (this.isEmpty()) {
return false;
} for ( var key in this.entrySet) {
if (this.entrySet[key] == value) {
return true;
}
} return false;
}; proto.get = function(key) {
if (this.isEmpty()) {
return null;
} if (this.containsKey(key)) {
return this.entrySet[key];
} return null;
}; proto.put = function(key, value) {
this.entrySet[key] = value;
this.count++;
}; proto.remove = function(key) {
if (this.containsKey(key)) {
delete this.entrySet[key];
this.count--;
}
}; proto.putAll = function(map) {
if(!map instanceof Map){
return;
} for ( var key in map.entrySet) {
this.put(key, map.entrySet[key]);
}
}; proto.clear = function() {
for ( var key in this.entrySet) {
this.remove(key);
}
}; proto.values = function() {
var result = []; for ( var key in this.entrySet) {
result.push(this.entrySet[key]);
} return result;
}; proto.keySet = function() {
var result = []; for ( var key in this.entrySet) {
result.push(key);
} return result;
}; proto.toString = function() {
var result = [];
for ( var key in this.entrySet) {
result.push(key + ":" + this.entrySet[key]);
} return "{" + result.join() + "}";
}; proto.valueOf = function() {
return this.toString();
}; win.Map = Map;
})(window);

// json2.js
// 2016-05-01
// Public Domain.
// NO WARRANTY EXPRESSED OR IMPLIED. USE AT YOUR OWN RISK.
// See http://www.JSON.org/js.html
// This code should be minified before deployment.
// See http://javascript.crockford.com/jsmin.html// USE YOUR OWN COPY. IT IS EXTREMELY UNWISE TO LOAD CODE FROM SERVERS YOU DO
// NOT CONTROL.// This file creates a global JSON object containing two methods: stringify
// and parse. This file is provides the ES5 JSON capability to ES3 systems.
// If a project might run on IE8 or earlier, then this file should be included.
// This file does nothing on ES5 systems.// JSON.stringify(value, replacer, space)
// value any JavaScript value, usually an object or array.
// replacer an optional parameter that determines how object
// values are stringified for objects. It can be a
// function or an array of strings.
// space an optional parameter that specifies the indentation
// of nested structures. If it is omitted, the text will
// be packed without extra whitespace. If it is a number,
// it will specify the number of spaces to indent at each
// level. If it is a string (such as "\t" or "&nbsp;"),
// it contains the characters used to indent at each level.
// This method produces a JSON text from a JavaScript value.
// When an object value is found, if the object contains a toJSON
// method, its toJSON method will be called and the result will be
// stringified. A toJSON method does not serialize: it returns the
// value represented by the name/value pair that should be serialized,
// or undefined if nothing should be serialized. The toJSON method
// will be passed the key associated with the value, and this will be
// bound to the value.// For example, this would serialize Dates as ISO strings.// Date.prototype.toJSON = function (key) {
// function f(n) {
// // Format integers to have at least two digits.
// return (n < 10)
// ? "0" + n
// : n;
// }
// return this.getUTCFullYear() + "-" +
// f(this.getUTCMonth() + 1) + "-" +
// f(this.getUTCDate()) + "T" +
// f(this.getUTCHours()) + ":" +
// f(this.getUTCMinutes()) + ":" +
// f(this.getUTCSeconds()) + "Z";
// };// You can provide an optional replacer method. It will be passed the
// key and value of each member, with this bound to the containing
// object. The value that is returned from your method will be
// serialized. If your method returns undefined, then the member will
// be excluded from the serialization.// If the replacer parameter is an array of strings, then it will be
// used to select the members to be serialized. It filters the results
// such that only members with keys listed in the replacer array are
// stringified.// Values that do not have JSON representations, such as undefined or
// functions, will not be serialized. Such values in objects will be
// dropped; in arrays they will be replaced with null. You can use
// a replacer function to replace those with JSON values.// JSON.stringify(undefined) returns undefined.// The optional space parameter produces a stringification of the
// value that is filled with line breaks and indentation to make it
// easier to read.// If the space parameter is a non-empty string, then that string will
// be used for indentation. If the space parameter is a number, then
// the indentation will be that many spaces.// Example:// text = JSON.stringify(["e", {pluribus: "unum"}]);
// // text is '["e",{"pluribus":"unum"}]'// text = JSON.stringify(["e", {pluribus: "unum"}], null, "\t");
// // text is '[\n\t"e",\n\t{\n\t\t"pluribus": "unum"\n\t}\n]'// text = JSON.stringify([new Date()], function (key, value) {
// return this[key] instanceof Date
// ? "Date(" + this[key] + ")"
// : value;
// });
// // text is '["Date(---current time---)"]'// JSON.parse(text, reviver)
// This method parses a JSON text to produce an object or array.
// It can throw a SyntaxError exception.// The optional reviver parameter is a function that can filter and
// transform the results. It receives each of the keys and values,
// and its return value is used instead of the original value.
// If it returns what it received, then the structure is not modified.
// If it returns undefined then the member is deleted.// Example:// // Parse the text. Values that look like ISO date strings will
// // be converted to Date objects.// myData = JSON.parse(text, function (key, value) {
// var a;
// if (typeof value === "string") {
// a =
// /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2}(?:\.\d*)?)Z$/.exec(value);
// if (a) {
// return new Date(Date.UTC(+a[1], +a[2] - 1, +a[3], +a[4],
// +a[5], +a[6]));
// }
// }
// return value;
// });// myData = JSON.parse('["Date(09/09/2001)"]', function (key, value) {
// var d;
// if (typeof value === "string" &&
// value.slice(0, 5) === "Date(" &&
// value.slice(-1) === ")") {
// d = new Date(value.slice(5, -1));
// if (d) {
// return d;
// }
// }
// return value;
// });// This is a reference implementation. You are free to copy, modify, or
// redistribute./*jslint
eval, for, this
*//*property
JSON, apply, call, charCodeAt, getUTCDate, getUTCFullYear, getUTCHours,
getUTCMinutes, getUTCMonth, getUTCSeconds, hasOwnProperty, join,
lastIndex, length, parse, prototype, push, replace, slice, stringify,
test, toJSON, toString, valueOf
*/// Create a JSON object only if one does not already exist. We create the
// methods in a closure to avoid creating global variables.if (typeof JSON !== "object") {
JSON = {};
}(function () {
"use strict"; var rx_one = /^[\],:{}\s]*$/;
var rx_two = /\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g;
var rx_three = /"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g;
var rx_four = /(?:^|:|,)(?:\s*\[)+/g;
var rx_escapable = /[\\\"\u0000-\u001f\u007f-\u009f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g;
var rx_dangerous = /[\u0000\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g; function f(n) {
// Format integers to have at least two digits.
return n < 10
? "0" + n
: n;
} function this_value() {
return this.valueOf();
} if (typeof Date.prototype.toJSON !== "function") { Date.prototype.toJSON = function () { return isFinite(this.valueOf())
? this.getUTCFullYear() + "-" +
f(this.getUTCMonth() + 1) + "-" +
f(this.getUTCDate()) + "T" +
f(this.getUTCHours()) + ":" +
f(this.getUTCMinutes()) + ":" +
f(this.getUTCSeconds()) + "Z"
: null;
}; Boolean.prototype.toJSON = this_value;
Number.prototype.toJSON = this_value;
String.prototype.toJSON = this_value;
} var gap;
var indent;
var meta;
var rep; function quote(string) {// If the string contains no control characters, no quote characters, and no
// backslash characters, then we can safely slap some quotes around it.
// Otherwise we must also replace the offending characters with safe escape
// sequences. rx_escapable.lastIndex = 0;
return rx_escapable.test(string)
? "\"" + string.replace(rx_escapable, function (a) {
var c = meta[a];
return typeof c === "string"
? c
: "\\u" + ("0000" + a.charCodeAt(0).toString(16)).slice(-4);
}) + "\""
: "\"" + string + "\"";
} function str(key, holder) {// Produce a string from holder[key]. var i; // The loop counter.
var k; // The member key.
var v; // The member value.
var length;
var mind = gap;
var partial;
var value = holder[key];// If the value has a toJSON method, call it to obtain a replacement value. if (value && typeof value === "object" &&
typeof value.toJSON === "function") {
value = value.toJSON(key);
}// If we were called with a replacer function, then call the replacer to
// obtain a replacement value. if (typeof rep === "function") {
value = rep.call(holder, key, value);
}// What happens next depends on the value's type. switch (typeof value) {
case "string":
return quote(value); case "number":// JSON numbers must be finite. Encode non-finite numbers as null. return isFinite(value)
? String(value)
: "null"; case "boolean":
case "null":// If the value is a boolean or null, convert it to a string. Note:
// typeof null does not produce "null". The case is included here in
// the remote chance that this gets fixed someday. return String(value);// If the type is "object", we might be dealing with an object or an array or
// null. case "object":// Due to a specification blunder in ECMAScript, typeof null is "object",
// so watch out for that case. if (!value) {
return "null";
}// Make an array to hold the partial results of stringifying this object value. gap += indent;
partial = [];// Is the value an array? if (Object.prototype.toString.apply(value) === "[object Array]") {// The value is an array. Stringify every element. Use null as a placeholder
// for non-JSON values. length = value.length;
for (i = 0; i < length; i += 1) {
partial[i] = str(i, value) || "null";
}// Join all of the elements together, separated with commas, and wrap them in
// brackets. v = partial.length === 0
? "[]"
: gap
? "[\n" + gap + partial.join(",\n" + gap) + "\n" + mind + "]"
: "[" + partial.join(",") + "]";
gap = mind;
return v;
}// If the replacer is an array, use it to select the members to be stringified. if (rep && typeof rep === "object") {
length = rep.length;
for (i = 0; i < length; i += 1) {
if (typeof rep[i] === "string") {
k = rep[i];
v = str(k, value);
if (v) {
partial.push(quote(k) + (
gap
? ": "
: ":"
) + v);
}
}
}
} else {// Otherwise, iterate through all of the keys in the object. for (k in value) {
if (Object.prototype.hasOwnProperty.call(value, k)) {
v = str(k, value);
if (v) {
partial.push(quote(k) + (
gap
? ": "
: ":"
) + v);
}
}
}
}// Join all of the member texts together, separated with commas,
// and wrap them in braces. v = partial.length === 0
? "{}"
: gap
? "{\n" + gap + partial.join(",\n" + gap) + "\n" + mind + "}"
: "{" + partial.join(",") + "}";
gap = mind;
return v;
}
}// If the JSON object does not yet have a stringify method, give it one. if (typeof JSON.stringify !== "function") {
meta = { // table of character substitutions
"\b": "\\b",
"\t": "\\t",
"\n": "\\n",
"\f": "\\f",
"\r": "\\r",
"\"": "\\\"",
"\\": "\\\\"
};
JSON.stringify = function (value, replacer, space) {// The stringify method takes a value and an optional replacer, and an optional
// space parameter, and returns a JSON text. The replacer can be a function
// that can replace values, or an array of strings that will select the keys.
// A default replacer method can be provided. Use of the space parameter can
// produce text that is more easily readable. var i;
gap = "";
indent = "";// If the space parameter is a number, make an indent string containing that
// many spaces. if (typeof space === "number") {
for (i = 0; i < space; i += 1) {
indent += " ";
}// If the space parameter is a string, it will be used as the indent string. } else if (typeof space === "string") {
indent = space;
}// If there is a replacer, it must be a function or an array.
// Otherwise, throw an error. rep = replacer;
if (replacer && typeof replacer !== "function" &&
(typeof replacer !== "object" ||
typeof replacer.length !== "number")) {
throw new Error("JSON.stringify");
}// Make a fake root object containing our value under the key of "".
// Return the result of stringifying the value. return str("", {"": value});
};
}// If the JSON object does not yet have a parse method, give it one. if (typeof JSON.parse !== "function") {
JSON.parse = function (text, reviver) {// The parse method takes a text and an optional reviver function, and returns
// a JavaScript value if the text is a valid JSON text. var j; function walk(holder, key) {// The walk method is used to recursively walk the resulting structure so
// that modifications can be made. var k;
var v;
var value = holder[key];
if (value && typeof value === "object") {
for (k in value) {
if (Object.prototype.hasOwnProperty.call(value, k)) {
v = walk(value, k);
if (v !== undefined) {
value[k] = v;
} else {
delete value[k];
}
}
}
}
return reviver.call(holder, key, value);
}// Parsing happens in four stages. In the first stage, we replace certain
// Unicode characters with escape sequences. JavaScript handles many characters
// incorrectly, either silently deleting them, or treating them as line endings. text = String(text);
rx_dangerous.lastIndex = 0;
if (rx_dangerous.test(text)) {
text = text.replace(rx_dangerous, function (a) {
return "\\u" +
("0000" + a.charCodeAt(0).toString(16)).slice(-4);
});
}// In the second stage, we run the text against regular expressions that look
// for non-JSON patterns. We are especially concerned with "()" and "new"
// because they can cause invocation, and "=" because it can cause mutation.
// But just to be safe, we want to reject all unexpected forms.// We split the second stage into 4 regexp operations in order to work around
// crippling inefficiencies in IE's and Safari's regexp engines. First we
// replace the JSON backslash pairs with "@" (a non-JSON character). Second, we
// replace all simple value tokens with "]" characters. Third, we delete all
// open brackets that follow a colon or comma or that begin the text. Finally,
// we look to see that the remaining characters are only whitespace or "]" or
// "," or ":" or "{" or "}". If that is so, then the text is safe for eval. if (
rx_one.test(
text
.replace(rx_two, "@")
.replace(rx_three, "]")
.replace(rx_four, "")
)
) {// In the third stage we use the eval function to compile the text into a
// JavaScript structure. The "{" operator is subject to a syntactic ambiguity
// in JavaScript: it can begin a block or an object literal. We wrap the text
// in parens to eliminate the ambiguity. j = eval("(" + text + ")");// In the optional fourth stage, we recursively walk the new structure, passing
// each name/value pair to a reviver function for possible transformation. return (typeof reviver === "function")
? walk({"": j}, "")
: j;
}// If the text is not JSON parseable, then a SyntaxError is thrown. throw new SyntaxError("JSON.parse");
};
}
}());

<%@ page language="java" import="java.util.*" pageEncoding="utf-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<meta charset="utf-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge"> <!-- Bootstrap core CSS -->
<link href="<%=request.getContextPath() %>/js/bootstrap/css/bootstrap.min.css" rel="stylesheet"></head>
<body>
<div class="contener">
<div class="row">
<div class="col-sm-6">
<div class="panel panel-default">
<div class="panel-heading">
dataGrid 数据
</div>
<div class="panel-body">
var dataJson = {"total":28,"rows":[ <br>
{"productid":"FI-SW-01","productname":"Koi"},<br>
{"productid":"K9-DL-01","productname":"Dalmation"},<br>
{"productid":"RP-SN-01","productname":"Rattlesnake"},<br>
{"productid":"RP-SN-01","productname":"Rattlesnake"},<br>
{"productid":"RP-LI-02","productname":"Iguana"}<br>
]}
</div>
</div>
</div> <div class="col-sm-6">
<div class="panel panel-default">
<div class="panel-heading">
要合并的属性
</div>
<div class="panel-body">
var paramJson = {<br>
'FI-SW-01,Koi':{name:'tomy',address:'北京海淀'},<br>
'RP-SN-01,Rattlesnake':{age: 21},<br>
'RP-LI-02,Iguana':{sex:'男'}<br>
};
</div>
</div>
</div>
</div> <div class="row">
<div class="col-sm-12">
<div class="panel panel-default">
<div class="panel-heading">
合并后结果
</div>
<div class="panel-body">
<p id="result"></p>
</div>
</div>
</div>
</div>
</div></body>
<script src="<%=request.getContextPath()%>/js/jquery/jquery-1.8.3.js"></script>
<script src="<%=request.getContextPath() %>/js/bootstrap/js/bootstrap.min.js"></script>
<script type="text/javascript">
var dataJson = {"total":28,"rows":[
{"productid":"FI-SW-01","productname":"Koi"},
{"productid":"K9-DL-01","productname":"Dalmation"},
{"productid":"RP-SN-01","productname":"Rattlesnake"},
{"productid":"RP-SN-01","productname":"Rattlesn"},
{"productid":"RP-LI-02","productname":"Iguana"}
]};
var paramJson = {'FI-SW-01,Koi':{productname:'tomy',address:'北京海淀'},
'RP-SN-01,Rattlesnake':{age: 21},
'RP-LI-02,Iguana':{sex:'男'}};
var indexKeys = ['productid','productname'];
function combineDataGrid(dataJson,paramJson,indexKeys){
var rows = dataJson.rows;
$.each(rows,function(index,item){
var keyIndex = '';
$.each(indexKeys,function(index,value){
if(index == 0) keyIndex += item[value];
else keyIndex += ','+item[value];
});
if(paramJson[keyIndex] && typeof paramJson[keyIndex] =="object")
item = $.extend(item,paramJson[keyIndex]);
});
return dataJson;
}
combineDataGrid(dataJson,paramJson,indexKeys); $("#result").append('var dataJson = {"total":28,"rows":[');
$.each(dataJson.rows,function(index,item){
$("#result").append('<br>' +JSON.stringify(item));
});
$("#result").append('<br>]}');</script>
</html>

<script type="text/javascript">
var userAgent = navigator.userAgent,
rMsie = /(msie\s|trident.*rv:)([\w.]+)/,
rFirefox = /(firefox)\/([\w.]+)/,
rOpera = /(opera).+version\/([\w.]+)/,
rChrome = /(chrome)\/([\w.]+)/,
rSafari = /version\/([\w.]+).*(safari)/;
var browser;
var version;
var ua = userAgent.toLowerCase();
function uaMatch(ua){
var match = rMsie.exec(ua);
if(match != null){
return { browser : "IE", version : match[2] || "0" };
}
var match = rFirefox.exec(ua);
if (match != null) {
return { browser : match[1] || "", version : match[2] || "0" };
}
var match = rOpera.exec(ua);
if (match != null) {
return { browser : match[1] || "", version : match[2] || "0" };
}
var match = rChrome.exec(ua);
if (match != null) {
return { browser : match[1] || "", version : match[2] || "0" };
}
var match = rSafari.exec(ua);
if (match != null) {
return { browser : match[2] || "", version : match[1] || "0" };
}
if (match != null) {
return { browser : "", version : "0" };
}
}
var browserMatch = uaMatch(userAgent.toLowerCase());
if (browserMatch.browser){
browser = browserMatch.browser;
version = browserMatch.version;
}
document.write(browser+version);
</script>

<script type="text/javascript">
function changeEvt(){
alert(1);
}
function clickEvt(){
$("input[name='age'][value='0']").attr("checked",true);
$("input[name='age'][value='0']").trigger("click");
}
(function ($) {
$.fn.inputRadio = function (op) {
return this.each(function(){
var changeInput = eval("(" + $(this).attr("data-option") + ")").changeInput;
var id = $(this).attr("id");
var txt = $(this),
strHtml = '<input type="radio" name="age" value="1" "/>是'+
'<input type="radio" name="age" value="0" "/>否';
txt.after(strHtml);
txt.remove();
$('input[name="age"]').bind("click", function(){
var nameA = $(this).attr("name");
if(changeInput){
eval(changeInput);
}
});
});
};
})(jQuery); $(".inputRadio").inputRadio();
</script>