澳门新萄京官方网站-www.8455.com-澳门新萄京赌场网址

常用运行库,JavaScript中判断对象类型的几种方法

2019-06-08 作者:澳门新萄京赌场网址   |   浏览(56)

JavaScript 原生对象及扩充

2016/09/26 · JavaScript · 对象

初稿出处: trigkit4   

新近在JavaSript进行Array操作的时候开掘并未有删除节点的措施,而笔者要兑现的成效供给不断调用删除节点的情势,查找了连带资料开掘能够行使prototype属性给Array扩充删除节点的办法,并且该格局同Array自己具备的push()、pop()、reverse()、slice()、sort()、join()等方法一致使用。

一、 javascript的typeof重返哪些数据类型

alert(typeof [1, 2]);    //object 

alert(typeof 'leipeng');    //string   

var i = true;    alert(typeof i);  //boolean   

alert(typeof 1);    //number   

var a;    alert(typeof a);  //undefined 

function a(){;};    alert(typeof a)  //function

var a = null;alert(typeof a); //object 解释:null是二个唯有1个值的数据类型,那个值正是null。表示一个空指针对象,所以用typeof检验会重返”object ”

/****************************************************************
    JScript 常用运转库    Version 一.1壹
                    
    作者    :    Lostinet[迷失网络]
    Email    :    lostinet@chongjian.com
****************************************************************/

咱俩精通,JavaScript中检测对象类型的演算符有:typeof、instanceof,还大概有对象的constructor属性:

放到对象与原生对象

内置(Build-in)对象与原生(Naitve)对象的界别在于:前者总是在内燃机开端化阶段就被创制好的靶子,是后者的3个子集;而后者包蕴了部分在运维进程中动态创造的靶子。

图片 1

 

function LostinetJScriptRuntimeLibrary(){}

1) typeof 运算符 typeof 是一元运算符,再次来到结果是3个认证运算数类型的字符串。如:"number","string","boolean","object","function","undefined"(可用以判别变量是或不是存在)。 但 typeof 的力量轻巧,其对于Date、RegExp类型再次回到的都以"object"。如:

原生对象(New后的对象)

ECMA-262 把原生对象(native object)定义为“独立于宿主意况的 ECMAScript 完结提供的靶子”。蕴涵如下:

Object、Function、Array、String、Boolean、Number、Date、RegExp、Error、EvalError、RangeError、ReferenceError、SyntaxError、TypeError、UXC60IError、ActiveXObject(服务器方面)、Enumerator(集合遍历类)、RegExp(正则表达式)

1
Object、Function、Array、String、Boolean、Number、Date、RegExp、Error、EvalError、RangeError、ReferenceError、SyntaxError、TypeError、URIError、ActiveXObject(服务器方面)、Enumerator(集合遍历类)、RegExp(正则表达式)

通过能够看来,轻巧的话,原生对象正是 ECMA-262 定义的类(引用类型)。

来源:

代码1

2、例举3种强制类型调换和二种隐式类型调换?

强制(parseInt() , parseFloat() , Number() )

隐式(== ,!!)

/****************************************************************
    Global
****************************************************************/
function Global(){}
function Global.GetUndefined(){}
function Global.ValueOf(unknown){
    if(Global.IsUndefined(unknown))return Global.GetUndefined();
    try{
        return unknown.valueOf();
    }catch(x){}
    return unknown;
}

typeof {}; // "object"
typeof []; // "object"
typeof new Date(); // "object"

置于对象(不须求New)

概念:由ECMAScript达成提供的目的,独立于宿主意况,在1个本子程序实行的启幕处。

:每一个内置对象(built-in object)都是原生对象(Native Object),1个内置的构造函数是一个放权的目的,也是三个构造函数。

来源:

举个栗子:

Native objects: Object (constructor), Date, Math, parseInt, eval。 string 方法比方 indexOf 和 replace, array 方法, ... Host objects (假定是浏览器意况): window, document, location, history, XMLHttpRequest, setTimeout, getElementsByTagName, querySelectorAll, ...

1
2
3
Native objects: Object (constructor), Date, Math, parseInt, eval。 string 方法比如 indexOf 和 replace, array 方法, ...
 
Host objects (假定是浏览器环境): window, document, location, history, XMLHttpRequest, setTimeout, getElementsByTagName, querySelectorAll, ...

ECMA-262][二 只定义了五个新的松开对象,即 GlobalMath (它们也是原生对象,根据定义,每一个内置对象都是原生对象)。

以下是ECMA-262概念的放置对象(built-in):

global、Object、Function、Array、String、Boolean、Number、Math、Date、RegExp、JSON、Error对象(Error, EvalError, RangeError, ReferenceError, SyntaxError, TypeError 和URIError)

1
global、Object、Function、Array、String、Boolean、Number、Math、Date、RegExp、JSON、Error对象(Error,   EvalError, RangeError, ReferenceError,   SyntaxError, TypeError 和URIError)

图片 2

作者们也足以修改内置对象的原型

JavaScript

if (!Array.prototype.forEach) { Array.prototype.forEach = function(fn){ for ( var i = 0; i < this.length; i ) { fn( this[i], i, this ); } }; } ["a", "b", "c"].forEach(function(value, index, array){ assert( value, "Is in position " index " out of " (array.length - 1) ); });

1
2
3
4
5
6
7
8
9
10
11
if (!Array.prototype.forEach) {
  Array.prototype.forEach = function(fn){
    for ( var i = 0; i < this.length; i ) {
      fn( this[i], i, this );
    }
  };
}
["a", "b", "c"].forEach(function(value, index, array){
  assert( value, "Is in position " index " out of " (array.length - 1) );
});

上述代码将出口:

PASS Is in position 0 out of 2 PASS Is in position 1 out of 2 PASS Is in position 2 out of 2

1
2
3
PASS Is in position 0 out of 2
PASS Is in position 1 out of 2
PASS Is in position 2 out of 2

在意:扩大原型是很凶险的:

JavaScript

Object.prototype.keys = function(){ var keys = []; for ( var i in this ) keys.push( i ); return keys; }; var obj = { a: 1, b: 2, c: 3 }; assert( obj.keys().length == 3, "We should only have 3 properties." ); delete Object.prototype.keys;

1
2
3
4
5
6
7
8
9
10
11
12
Object.prototype.keys = function(){
  var keys = [];
  for ( var i in this )
    keys.push( i );
  return keys;
};
var obj = { a: 1, b: 2, c: 3 };
assert( obj.keys().length == 3, "We should only have 3 properties." );
delete Object.prototype.keys;

输出: FAIL We should only have 3 properties.

只要不是有独具匠心供给而去扩展原生对象和原型(prototype)的做法是不好的

JavaScript

//不要那样做 Array.prototype.map = function() { // code };

1
2
3
4
//不要这样做
Array.prototype.map = function() {
    // code
};

除非那样做是值得的,比如,向一些旧的浏览器中增添一些ECMAScript5中的方法。
在这种情况下,大家一般那样做:

XHTML

<script type="text/javascript"> if (!Array.prototype.map) { Array.prototype.map = function() { //code }; } </script>

1
2
3
4
5
6
7
<script type="text/javascript">
    if (!Array.prototype.map) {
        Array.prototype.map = function() {
            //code
        };
    }
</script>

[javascript]  

3、split()、join() 的区别

前端是切割成数组的情势,后者是将数组调换来字符串

function Global.ToString(unknown){
    if(Global.IsUndefined(unknown))return "";
    if(Global.IsJScriptObject(unknown))
    {
        try{
            return String.Convert(unknown.toString());
        }catch(x){}
    }
    return String.Convert(unknown);
}
function Global.IsBlank(unknown){
    switch(typeof(unknown))
    {
    case "undefined":return true;
    case "string":return unknown=="";
    case "number":return unknown==0;
    case "object":return unknown==null;
    case "function":return false;
    default:return unknown?false:true;
    }
}
function Global.IsJScriptType(unknown)
{
    switch(typeof(unknown))
    {
    case "object":
        return Global.IsJScriptObject(unknown);
    case "function":
    case "string":
    case "number":
    case "boolean":
    case "undefined":
        return true;
    default:
        return false;
    }
}
function Global.IsJScriptObject(unknown)
{
    if(typeof(unknown)=="function")return true;
    if(typeof(unknown)!="object")return false;
    try{
        return typeof(unknown.constructor)=="function";
    }catch(x){
    }
    return false;
}
function Global.ThrowError(msg){
    throw(new Error(-1,msg));
}
/****************************************************************
    Object
****************************************************************/

故此它只在区分对象和原始类型的时候才有用。要区1种对象类型和另壹种对象类型,必须接纳此外的措施。如:instanceof 运算符或对象的 constructor 属。

用原型扩充对象

对js原生对象的恢宏无非正是往prototype里登记,比方,大家得现在String指标里扩大ltrim,rtrim等艺术。js每种对象都持续自Object,并且,对象和其它属性都由此prototype目标来再而三。通过prototype指标,大家可以扩充任何对象,包罗内建的靶子,如StringDate

Array.prototype.remove = function (dx) {  

肆、数组方法 pop()  push()  unshift()  shift()

push() 尾巴部分增加      pop() 尾巴部分删除

unshift() 尾部增添  shift() 底部剔除

map() : 遍历数组中的成分, 再次回到二个新数组(包含回调函数再次来到的数额)

filter():遍历数组中的成分, 重回多个新数组(包蕴回调函数再次来到true的要素)

/*
unknown,function,ActiveXObject等会被以为是undefined
而外Object和Array,别的object类型的子属性会被忽视
自定义的constructor会自动转为Object
*/
//需求优化
function Object.Encode(v)
{
    var Encoders={"unknown":_unknown,"object":_object,"function":_function,"string":_string,"number":_number,"boolean":_boolean,"undefined":_undefined};
    return InnerEncode(v);
    function InnerEncode(v)
    {
        var der=Encoders[typeof(v)];
        if(der)
            return der(v);
        return _undefined(v);
    }
    function EncodeString(v){
        v=String.Convert(v);
        v=v.replace(/&/g,"&0");
        v=v.replace(/=/g,"&1");
        v=v.replace(/:/g,"&2");
        v=v.replace(/,/g,"&3");
        return v;
    }
    function _unknown(v)
    {
        return _undefined(v);
    }
    function _object(v)
    {
        if(!Global.IsJScriptObject(v))
            return _undefined(v);
        switch(v.constructor)
        {
        case Array:        return _Array(v);
        case Date:        return _Date(v);
        case String:    return _String(v);
        case Number:    return _Number(v);
        case Boolean:    return _Boolean(v);
        case RegExp:    return _RegExp(v);
        case Object:
        default:
            return _Object(v);
        }
        function _Object(v)
        {
            var str="object_Object=";
            var arr=[];
            for(var i in v)
            {
                if(Global.IsJScriptType(v[i])&&typeof(v[i])!="function")
                    arr[arr.length]=EncodeString(EncodeString(i) ":" EncodeString(InnerEncode(v[i])));
            }
            return str arr.join(",");
        }
        function _Array(v)
        {
            var str="object_Array=";
            var arr=[];
            for(var i in v)
            {
                if(Global.IsJScriptType(v[i])&&typeof(v[i])!="function")
                    arr[arr.length]=EncodeString(EncodeString(i) ":" EncodeString(InnerEncode(v[i])));
            }
            return str arr.join(",");
        }
        function _Date(v){return "object_Date=" v.getTime();}
        function _String(v){return "object_String=" EncodeString(v);}
        function _Number(v){return "object_Number=" EncodeString(v);}
        function _Boolean(v){return "object_Boolean=" EncodeString(v.ToString());}
        function _RegExp(v)
        {
            return "object_RegExp="
                EncodeString(
                    "p:" EncodeString(v)
                    "i:" EncodeString(Boolean.ToString(v.ignoreCase))
                    "g:" EncodeString(Boolean.ToString(v.global))
                );
        }
    }
    function _function(v){return _undefined(v);}
    function _string(v){return "string=" EncodeString(v);}
    function _number(v){return "number=" EncodeString(v);}
    function _boolean(v){return "boolean=" EncodeString(v.ToString());}
    function _undefined(v){return "undefined=undefined";}
}
//必要优化
function Object.Decode(s)
{
    s=String.Convert(s);
    var Decoders={"object_Object":_object_Object,"object_Array":_object_Array,"object_Date":_object_Date,"object_String":_object_String,"object_Number":_object_Number,"object_Boolean":_object_Boolean,"object_RegExp":_object_RegExp,"string":_string,"number":_number,"boolean":_boolean,"undefined":_undefined};
    return InnerDecode(s);
    function InnerDecode(s)
    {
        s=String.Convert(s);
        var arr=s.split("=");
        var type=arr[0];
        var der=Decoders[type];
        if(der)
            return der(String.Convert(arr[1]));
        return _undefined(String.Convert(arr[1]));
    }
    function DecodeString(v){
        v=String.Convert(v);
        v=v.replace(/&3/g,",");
        v=v.replace(/&2/g,":");
        v=v.replace(/&1/g,"=");
        v=v.replace(/&0/g,"&");
        return v;
    }
    function _object_Object(ss)
    {
        var obj=new Object();
        var arr=ss.split(",");
        for(var i=0;i<arr.length;i )
        {
            var arr2=DecodeString(arr[i]).split(":");
            var index=DecodeString(arr2[0]);
            if(index=="")break;
            obj[index]=InnerDecode(DecodeString(arr2[1]));
        }
        return obj;
    }
    function _object_Array(ss)
    {
        var obj=new Array();
        var arr=ss.split(",");
        for(var i=0;i<arr.length;i )
        {
            var arr2=DecodeString(arr[i]).split(":");
            var index=DecodeString(arr2[0]);
            if(index=="")break;
            obj[index]=InnerDecode(DecodeString(arr2[1]));
        }
        return obj;
    }
    function _object_Date(ss){return Date.Convert(Number.Convert(DecodeString(ss)));}
    function _object_String(ss){return new String(String.Convert(DecodeString(ss)));}
    function _object_Number(ss){return new Number(Number.Convert(DecodeString(ss)));}
    function _object_Boolean(ss){return new Boolean(Boolean.ConvertFromString(DecodeString(ss)));}
    function _object_RegExp(ss)
    {
        var obj=new Object();
        var arr=ss.split(",");
        for(var i=0;i<arr.length;i )
        {
            var arr2=DecodeString(arr[i]).split(":");
            var index=DecodeString(arr2[0]);
            if(index=="")break;
            obj[index]=InnerDecode(DecodeString(arr2[1]));
        }
        var re=new RegExp();
        re.pattern=String.Convert(obj.p);
        re.ignoreCase=Boolean.Convert(obj.i);
        re.global=Boolean.Convert(obj.g);
        return re;
    }
    function _string(ss){return String.Convert(DecodeString(ss));}
    function _number(ss){return Number.Convert(DecodeString(ss));}
    function _boolean(ss){return Boolean.ConvertFromString(DecodeString(ss));}
    function _undefined(ss){return Global.GetUndefined();}
}

2)instanceof 运算符。 instanceof 运算符要求其左边的运算数是3个对象,左边的运算数是对象类的名字或构造函数。要是object 是 class 或构造函数的实例,则 instanceof 运算符重临 true。要是object 不是钦点类或函数的实例,或然 object 为 null,则赶回 false。如:

String对象的强大

JavaScript

<script type="text/javascript"> if(typeof String.prototype.ltrim=='undefined'){ String.prototype.ltrim = function(){ var s = this; s = s.replace(/^s*/g, ''); return s; } } if(typeof String.prototype.rtrim=='undefined'){ String.prototype.rtrim = function(){ var s = this; s = s.replace(/s*$/g, ''); return s; } } if(typeof String.prototype.trim=='undefined'){ String.prototype.trim = function(){ return this.ltrim().rtrim(); } } if(typeof String.prototype.htmlEncode=='undefined'){ String.prototype.htmlEncode = function(encodeNewLine){//encodeNewLine:是否encode换行符 var s = this; s = s.replace(/&/g, '&'); s = s.replace(/</g, '<'); s = s.replace(/>/g, '>'); s = s.replace(/'/g, '"'); if(encodeNewLine){ s = s.replace(/rn/g, '<br />'); s = s.replace(/r/g, '<br />'); s = s.replace(/n/g, '<br />'); } return s; } } </script>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
<script type="text/javascript">
    if(typeof String.prototype.ltrim=='undefined'){
        String.prototype.ltrim = function(){
            var s = this;
            s = s.replace(/^s*/g, '');
            return s;
        }
    }
 
    if(typeof String.prototype.rtrim=='undefined'){
        String.prototype.rtrim = function(){
            var s = this;
            s = s.replace(/s*$/g, '');
            return s;
        }
    }
 
    if(typeof String.prototype.trim=='undefined'){
        String.prototype.trim = function(){
            return this.ltrim().rtrim();
        }
    }
 
    if(typeof String.prototype.htmlEncode=='undefined'){
        String.prototype.htmlEncode = function(encodeNewLine){//encodeNewLine:是否encode换行符
            var s = this;
            s = s.replace(/&/g, '&amp;');
            s = s.replace(/</g, '&lt;');
            s = s.replace(/>/g, '&gt;');
            s = s.replace(/'/g, '&quot;');
            if(encodeNewLine){
                s = s.replace(/rn/g, '<br />');
                s = s.replace(/r/g, '<br />');
                s = s.replace(/n/g, '<br />');
            }
            return s;
        }
    }
</script>

        if (isNaN(dx) || dx > this.length) { return false; }  

5、IE和DOM事件流的不一样

1.奉行顺序不雷同、

二.参数不等同

三.轩然大波加不加on

四.this指向难题

function Object.EncodeJScript(v)
{
    if(Boolean.IsFalse(Global.IsJScriptType(v)))
    {
        return _undefined(v);
    }
    return eval("_" typeof(v))(v);
    function _object(v)
    {
        if(Boolean.IsFalse(Global.IsJScriptObject(v)))return _undefined(v);
        switch(v.constructor)
        {
        case Object:    return _Object(v);
        case Array:        return _Array(v);
        case Date:        return _Date(v);
        case String:    return _String(v);
        case Number:    return _Number(v);
        case Boolean:    return _Boolean(v);
        case RegExp:    return _RegExp(v);
        default:
            if(typeof(v.constructor)=="function")return _Object(v);
        }
        return _undefined(v);
    }
    function _Object(v)
    {
        var arr=[];
        for(var i in v)
        {
            if(typeof(v[i])!="function"&&Global.IsJScriptType(v[i]))
                arr[arr.length]='"' String.EncodeJScript(i) '":' eval("_" typeof(v[i]))(v[i]);
        }
        return "{" arr.join(",") "}";
    }
    function _Array(v)
    {
        var arr=[];
        for(var i in v)
        {
            if(typeof(v[i])!="function"&&Global.IsJScriptType(v[i]))
                arr[arr.length]=eval("_" typeof(v[i]))(v[i]);
        }
        return "[" arr.join(",") "]";
    }
    function _Date(v){return "new Date("" String.EncodeJScript(new Date().toUTCString()) "")";}
    function _String(v){return "new String("" String.EncodeJScript(v) "")";}
    function _Number(v){return "new Number(" Number.Convert(v) ")";}
    function _Boolean(v){return "new Boolean(" Boolean.ToString(v) ")";}
    function _RegExp(v){return "new RegExp(" v ")";}    
    function _function(v){return "(function(){})()";}
    function _string(v){return """ String.EncodeJScript(v) """}
    function _number(v){return String.Convert(v);}
    function _boolean(v){return Boolean.ToString(v);}
    function _undefined(v){return "(function(){})()";}
    function _unknown(s){return "(function(){})()";}
}
function Object.DecodeJScript(s)
{
    s=String.Convert(s);
    if(s=="")return null;
    if(s=="undefined")return GetUndefined();
    var o=null;
    try{
        eval("o=" s);
    }catch(x){
        throw(new Error(-1,"Object.DecodeJScript不能够反编码n" x.description "n原代码是:n" s));
    }
    return o;
}

[] instanceof Array; // true
[] instanceof Object; // true
[] instanceof RegExp; // false
new Date instanceof Date; // true

Date对象的庞大

getDaysInMonth:获取某月有微微天

JavaScript

Date.getDaysInMonth = function (year, month) { var days = 0; switch (month) { case 1: case 3: case 5: case 7: case 8: case 10: case 12: days = 31 break; case 4: case 6: case 9: case 11: days = 30; break; case 2: if (year % 400 == 0 || (year % 4 == 0 && year % 100 != 0)) days = 29; else days = 28; break; } return days; } if (typeof Date.prototype.format == 'undefined') { Date.prototype.format = function (mask) { var d = this; var zeroize = function (value, length) { if (!length) length = 2; value = String(value); for (var i = 0, zeros = ''; i < (length - value.length); i ) { zeros = '0'; } return zeros value; }; return mask.replace(/"[^"]*"|'[^']*'|b(?:d{1,4}|m{1,4}|yy(?:yy)?|([hHMstT])1?|[lLZ])b/g, function ($0) { switch ($0) { case 'd': return d.getDate(); case 'dd': return zeroize(d.getDate()); case 'ddd': return ['Sun', 'Mon', 'Tue', 'Wed', 'Thr', 'Fri', 'Sat'][d.getDay()]; case 'dddd': return ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'][d.getDay()]; case 'M': return d.getMonth() 1; case 'MM': return zeroize(d.getMonth() 1); case 'MMM': return ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'][d.getMonth()]; case 'MMMM': return ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'][d.getMonth()]; case 'yy': return String(d.getFullYear()).substr(2); case 'yyyy': return d.getFullYear(); case 'h': return d.getHours() % 12 || 12; case 'hh': return zeroize(d.getHours() % 12 || 12); case 'H': return d.getHours(); case 'HH': return zeroize(d.getHours()); case 'm': return d.getMinutes(); case 'mm': return zeroize(d.getMinutes()); case 's': return d.getSeconds(); case 'ss': return zeroize(d.getSeconds()); case 'l': return zeroize(d.getMilliseconds(), 3); case 'L': var m = d.getMilliseconds(); if (m > 99) m = Math.round(m / 10); return zeroize(m); case 'tt': return d.getHours() < 12 ? 'am' : 'pm'; case 'TT': return d.getHours() < 12 ? 'AM' : 'PM'; case 'Z': return d.toUTCString().match(/[A-Z] $/); // Return quoted strings with the surrounding quotes removed default: return $0.substr(1, $0.length - 2); } }); }; }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
Date.getDaysInMonth = function (year, month) {
            var days = 0;
            switch (month) {
                case 1:
                case 3:
                case 5:
                case 7:
                case 8:
                case 10:
                case 12:
                    days = 31
                    break;
                case 4:
                case 6:
                case 9:
                case 11:
                    days = 30;
                    break;
                case 2:
                    if (year % 400 == 0 || (year % 4 == 0 && year % 100 != 0))
                        days = 29;
                    else
                        days = 28;
                    break;
            }
            return days;
        }
 
        if (typeof Date.prototype.format == 'undefined') {
            Date.prototype.format = function (mask) {
 
                var d = this;
 
                var zeroize = function (value, length) {
 
                    if (!length) length = 2;
 
                    value = String(value);
 
                    for (var i = 0, zeros = ''; i < (length - value.length); i ) {
 
                        zeros = '0';
 
                    }
 
                    return zeros value;
 
                };
 
                return mask.replace(/"[^"]*"|'[^']*'|b(?:d{1,4}|m{1,4}|yy(?:yy)?|([hHMstT])1?|[lLZ])b/g, function ($0) {
 
                    switch ($0) {
 
                        case 'd': return d.getDate();
 
                        case 'dd': return zeroize(d.getDate());
 
                        case 'ddd': return ['Sun', 'Mon', 'Tue', 'Wed', 'Thr', 'Fri', 'Sat'][d.getDay()];
 
                        case 'dddd': return ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'][d.getDay()];
 
                        case 'M': return d.getMonth() 1;
 
                        case 'MM': return zeroize(d.getMonth() 1);
 
                        case 'MMM': return ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'][d.getMonth()];
 
                        case 'MMMM': return ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'][d.getMonth()];
 
                        case 'yy': return String(d.getFullYear()).substr(2);
 
                        case 'yyyy': return d.getFullYear();
 
                        case 'h': return d.getHours() % 12 || 12;
 
                        case 'hh': return zeroize(d.getHours() % 12 || 12);
 
                        case 'H': return d.getHours();
 
                        case 'HH': return zeroize(d.getHours());
 
                        case 'm': return d.getMinutes();
 
                        case 'mm': return zeroize(d.getMinutes());
 
                        case 's': return d.getSeconds();
 
                        case 'ss': return zeroize(d.getSeconds());
 
                        case 'l': return zeroize(d.getMilliseconds(), 3);
 
                        case 'L': var m = d.getMilliseconds();
 
                            if (m > 99) m = Math.round(m / 10);
 
                            return zeroize(m);
 
                        case 'tt': return d.getHours() < 12 ? 'am' : 'pm';
 
                        case 'TT': return d.getHours() < 12 ? 'AM' : 'PM';
 
                        case 'Z': return d.toUTCString().match(/[A-Z] $/);
 
                            // Return quoted strings with the surrounding quotes removed    
 
                        default: return $0.substr(1, $0.length - 2);
 
                    }
 
                });
 
            };
        }

        for (var i = 0, n = 0; i < this.length; i ) {  

6、IE和正规下有哪些包容性的写法

var ev = ev || window.event

document.documentElement.clientWidth || document.body.clientWidth

var target = ev.srcElement||ev.target

/****************************************************************
    Function
****************************************************************/

据此,能够用instanceof运算符来推断指标是或不是为数组类型:

动用原生js完结复制对象及扩大

jQueryextend()主意能很方便的落到实处扩张对象方法,这里要贯彻的是:使用原生js兑现复制对象,增添对象,类似jQuery中的extend()方法

JavaScript

var obj一 = { name : 'trigkit肆', age : 2贰 }; var obj二 = { name : 'frank', age : 二一, speak : function(){ alert("hi, I'm name "); } }; var obj三 ={ age : 20 }; function cloneObj(oldObj) { //复制对象方法 if (typeof(oldObj) != 'object') return oldObj; if (oldObj == null) return oldObj; var newObj = Object(); for (var i in oldObj) newObj[i] = cloneObj(oldObj[i]); return newObj; } function extendObj() { //扩张对象 var args = arguments;//将传递过来的参数数组赋值给args变量 if (args.length < 二) return; var temp = cloneObj(args[0]); //调用复制对象方法 for (var n = 1; n < args.length; n ) { for (var i in args[n]) { temp[i] = args[n][i]; } } return temp; } var obj =extendObj(obj1,obj2,obj3); console.log(obj);//{ name: 'frank', age: 20, speak: [Function] } console.log(obj1);//{ name: 'trigkit4', age: 22 } console.log(obj2);//{ name: 'frank', age: 21, speak: [Function] } console.log(obj3);//{ age: 20 }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
var obj1 = {
    name : 'trigkit4',
    age : 22
};
var obj2 = {
    name : 'frank',
    age : 21,
    speak : function(){
        alert("hi, I'm name ");
    }
};
 
var obj3 ={
    age : 20
};
 
function cloneObj(oldObj) { //复制对象方法
    if (typeof(oldObj) != 'object') return oldObj;
    if (oldObj == null) return oldObj;
    var newObj = Object();
    for (var i in oldObj)
        newObj[i] = cloneObj(oldObj[i]);
    return newObj;
}
 
function extendObj() { //扩展对象
    var args = arguments;//将传递过来的参数数组赋值给args变量
    if (args.length < 2) return;
    var temp = cloneObj(args[0]); //调用复制对象方法
    for (var n = 1; n < args.length; n ) {
        for (var i in args[n]) {
            temp[i] = args[n][i];
        }
    }
    return temp;
}
var obj =extendObj(obj1,obj2,obj3);
console.log(obj);//{ name: 'frank', age: 20, speak: [Function] }
console.log(obj1);//{ name: 'trigkit4', age: 22 }
console.log(obj2);//{ name: 'frank', age: 21, speak: [Function] }
console.log(obj3);//{ age: 20 }

            if (this[i] != this[dx]) {  

7、call和apply的区别

效率雷同, 都以将近来函数作为内定对象的法子执行, 即函数中的this是点名对象

call(thisObj,arg1,arg二...)  //将全部参数贰个贰个传递进入

apply(thisObj,[argArray])  //将全数参数放在数组中传播

/*
基本协议!不容许有Function.prototype.XXX();
*/

function isArray(arr){
    return arr instanceof Array;
}

es5-safe 模块

es5-safe 模块里,仅扩展了足以较好贯彻的能够安全选择的一部分方法,包蕴:

JavaScript

Function.prototype.bind Object.create Object.keys Array.isArray Array.prototype.forEach Array.prototype.map Array.prototype.filter Array.prototype.every Array.prototype.some Array.prototype.reduce Array.prototype.reduceRight Array.prototype.indexOf Array.prototype.lastIndexOf String.prototype.trim Date.now

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Function.prototype.bind
Object.create
Object.keys
Array.isArray
Array.prototype.forEach
Array.prototype.map
Array.prototype.filter
Array.prototype.every
Array.prototype.some
Array.prototype.reduce
Array.prototype.reduceRight
Array.prototype.indexOf
Array.prototype.lastIndexOf
String.prototype.trim
Date.now

详情:

                this[n ] = this[i]  

8、怎么阻止事件冒泡和事件默许行为

//阻止事件冒泡

if(typeof ev.stopPropagation=='function') {  //标准的

              ev.stopPropagation();

} else { //非标准IE

              window.event.cancelBubble = true;

}

//阻止事件默许行为

return  false

/****************************************************************
    String
****************************************************************/
function String.Convert(v,dv)
{
    if(typeof(v)=="string")return v;
    if(typeof(dv)=="undefined")dv="";
    else dv=String.Convert(dv);    
    if(typeof(v)=="number")return v.toString();
    if(typeof(v)=="undefined")return dv;
    if(v===null)return dv;
    try{
        v=v ""
        if(v==="undefined")return dv;
        return String.Convert(v,dv);
    }catch(x){}
    return "[unconvertable]";
}
function String.ConvertArguments(args)
{
    if(typeof(args)!="object")
    {
        if(Global.IsBlank(String.ConvertArguments.caller))return "";
        args=String.ConvertArguments.caller.arguments;
    }
    return Array.ConvertArguments(args).join("");
}
function String.Random(count)
{
    var res="";
    for(var i=0;i<count;i )
    {
        var t=(Math.random()*62*1000)b;
        if(t<10)res =String.fromCharCode(t 48);
        else if(t<36)res =String.fromCharCode(t 55);
        else res =String.fromCharCode(t 61);
    }
    return res;
}

3)constructor 属性。 JavaScript中,每一种对象都有叁个constructor属性,它引用了起首化该目的的构造函数,常用于判定未知对象的花色。如给定二个求知的值 通过typeof运算符来判定它是土生土长的值照旧对象。要是是目的,就足以选用constructor属性来推断其种类。所以判定数组的函数也足以如此写:

指标的开创

JavaScript 扶助各种类型的对象:内部对象、生成的靶子、宿主给出的靶子(如 Internet 浏览器中的 windowdocument)以及ActiveX 对象(外部组件)。

Microsoft Jscript 提供了 11 个内部(或“内置”)对象。它们是Array、Boolean、Date、Function、Global、Math、Number、Object、RegExp、Error 以及 String 对象。每三个对象有相关的点子和性质,

JavaScript中目的的创建有以下两种艺术:

(一)使用内置对象 (2)使用JSON符号 (三)自定义对象协会

1
2
3
(1)使用内置对象
(2)使用JSON符号
(3)自定义对象构造

            }  

//补满0
function String.prototype.ToStringByZero(count)
{
    var str=this;
    while(str.length<count)str="0" str;
    return str;
}function String.ToStringByZero(str,count){return String.Convert(str).ToStringByZero(count);}

function isArray(arr){
    return typeof arr == "object" && arr.constructor == Array;
}

一、使用内置对象

JavaScript可用的嵌入对象可分为二种: 壹,JavaScript语言原生对象(语言级对象),如String、Object、Function等; 二,JavaScript运营期的宿主对象(情形宿主级对象),如window、document、body等。

1
2
3
4
JavaScript可用的内置对象可分为两种:
 
1,JavaScript语言原生对象(语言级对象),如String、Object、Function等;
2,JavaScript运行期的宿主对象(环境宿主级对象),如window、document、body等。

        }  

九、 增添 删除 替换 插入到有个别成分的主意

element.appendChild()

element.insertBefore()

element.replaceChild()

element.removeChild()

//编码SQL的常规字符串
function String.prototype.EncodeSQL()
{
    var str=this;
    str=str.replace(/x27/g,"''");
    return str;
}function String.EncodeSQL(str){return String.Convert(str).EncodeSQL();}
//用 Like 操作符时编码SQL
function String.prototype.EncodeSQLLike()
{
    var str=this;
    str=str.replace(/x60/g,"[`]");
    str=str.replace(/x7e/g,"[~]");
    str=str.replace(/x21/g,"[!]");
    str=str.replace(/x40/g,"[@]");
    str=str.replace(/x23/g,"[#]");
    str=str.replace(/x24/g,"[$]");
    str=str.replace(/x25/g,"[%]");
    str=str.replace(/x5e/g,"[^]");
    str=str.replace(/x26/g,"[&]");
    str=str.replace(/x2a/g,"[*]");
    str=str.replace(/x28/g,"[(]");
    str=str.replace(/x29/g,"[)]");
    str=str.replace(/x5f/g,"[_]");
    str=str.replace(/x2b/g,"[ ]");
    str=str.replace(/x7c/g,"[|]");
    str=str.replace(/x2d/g,"[-]");
    str=str.replace(/x3d/g,"[=]");
    str=str.replace(/x5c/g,"[]");
    str=str.replace(/x5b/g,"[[]");
    str=str.replace(/x5d/g,"[]]");
    str=str.replace(/x3b/g,"[;]");
    str=str.replace(/x27/g,"''");//str=str.replace(/x27/g,"[']");// ' => ''
    str=str.replace(/x2c/g,"[,]");
    str=str.replace(/x2e/g,"[.]");
    str=str.replace(/x2f/g,"[/]");
    str=str.replace(/x7b/g,"[{]");
    str=str.replace(/x7d/g,"[}]");
    str=str.replace(/x3a/g,"[:]");
    //str=str.replace(/x22/g,"["]");
    str=str.replace(/x3c/g,"[<]");
    str=str.replace(/x3e/g,"[>]");
    str=str.replace(/x3f/g,"[?]");
    return str;
}function String.EncodeSQLLike(str){return String.Convert(str).EncodeSQLLike();}

重重情景下,大家能够动用instanceof运算符或对象的constructor属性来检查测试对象是还是不是为数组。比如许多JavaScript框架正是利用那三种艺术来剖断目的是或不是为数组类型。 可是检验在跨框架(cross-frame)页面中的数组时,会停业。原因就是在分歧框架(iframe)中创立的数组不会相互共享其prototype属性。比如:

停放对象列表

Array Boolean Date Error EvalError Function Infinity JSON Map Math NaN Number Object ParallelArray Promise Proxy RegExp Set String Symbol SyntaxError Uint32Array WeakSet decodeURI decodeURIComponent() encodeURI() encodeURIComponent() escape()已废弃 eval() isFinite() isNaN() null parseFloat parseInt undefined

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
Array
Boolean
Date
Error
EvalError
Function
Infinity
JSON
Map
Math
NaN
Number
Object
ParallelArray
Promise
Proxy
RegExp
Set
String
Symbol
SyntaxError
Uint32Array
WeakSet
decodeURI
decodeURIComponent()
encodeURI()
encodeURIComponent()
escape()已废弃
eval()
isFinite()
isNaN()
null
parseFloat
parseInt
undefined

以上资料来源于:

        this.length -= 1  

10、javascript的停放对象和宿主对象

内置对象为Object, Array, Function, Date, Math等

宿主为浏览器自带的window 等

//编码成VBScript字符串,两边的引号已经加了""
常用运行库,JavaScript中判断对象类型的几种方法总结。function String.prototype.EncodeVBScript()
{
    var str=this;
    str=str.replace(/x22/g,"""");
    str=str.replace(/n/g,"" & vbNewline & _n"");
    str=str.replace(/r/g,"");
    return "_n"" str """;
}function String.EncodeVBScript(str){return String.Convert(str).EncodeVBScript();}

复制代码 代码如下:

自定义对象组织

创设高档对象组织有二种艺术:使用“this”关键字构造、使用原型prototype构造

    }  

11、window.onload和document ready的区别

window.onload 是在dom文书档案树加载完和兼具文件加载完之后实施二个函数

document.ready原生中绝非这么些主意,jquery中有 $().ready(function),在dom文书档案树加载完之后实施三个函数(注意,那之中的文书档案树加载完不意味全部文书加载完)。

$(document).ready要比window.onload先执行

window.onload只好出去三遍,$(document).ready能够出现数次

//编码成JScript字符串,不加两边的引号
function String.prototype.EncodeJScript()
{
    var str=this;
    str=str.replace(/x5c/g,"\\");
    str=str.replace(/x2f/g,"\/");
    str=str.replace(/x3cS/g,"\u003cS");
    str=str.replace(/x3cs/g,"\u003cs");
    str=str.replace(/x22/g,"\"");
    str=str.replace(/x27/g,"\'");
    str=str.replace(/t/g,"\t");
    str=str.replace(/n/g,"\n");
    str=str.replace(/r/g,"\r");
    return str;
}function String.EncodeJScript(str){return String.Convert(str).EncodeJScript();}

<script>
window.onload=function(){
var iframe_arr=new window.frames[0].Array;
alert(iframe_arr instanceof Array); // false
alert(iframe_arr.constructor == Array); // false
}
</script>

Date对象

 

12、”==”和“===”的不同

前端会活动调换类型

后来人不会

//保留换行,在服务器上解码会丢掉n
function String.prototype.EncodeJScriptCode()
{
    var str=this;
    str=str.replace(/x5c/g,"\\");
    str=str.replace(/x2f/g,"\/");
    str=str.replace(/x3cS/g,"\u003cS");
    str=str.replace(/x3cs/g,"\u003cs");
    str=str.replace(/x22/g,"\"");
    str=str.replace(/x27/g,"\'");
    str=str.replace(/t/g,"\t");
    str=str.replace(/n/g,"\n");
    str=str.replace(/r/g,"\r");
    return str;
}function String.EncodeJScriptCode(str){return String.Convert(str).EncodeJScriptCode();}

在Ajaxian上看看了壹种标准的检验方法,跨原型链调用toString()方法:Object.prototype.toString()。可以消除地点的跨框架难题。 当Object.prototype.toString(o)实行后,会进行以下步骤: 1)获取对象o的class属性。 二)连接字符串:"[object " 结果(1) "]" 3)返回 结果(2) 例如:

get体系措施

getDate() 从 Date 对象回到贰个月首的某一天 (一 ~ 3一)。 getDay() 从 Date 对象回来二十四日中的某一天 (0 ~ 陆)。 getMonth() 从 Date 对象回来月份 (0 ~ 1一)。 getFullYear() 从 Date 对象以3位数字重临年份。注意不要选拔getYear()。 getHours() 重返 Date 对象的时辰 (0 ~ 23)。 getMinutes() 重临 Date 对象的秒钟 (0 ~ 5玖)。 getSeconds() 重返 Date 对象的秒数 (0 ~ 5玖)。 get米尔iseconds() 再次来到 Date 对象的飞秒(0 ~ 99玖)。 getTime() 重临 一9陆七 年 1 月 壹 日现今的飞秒数。 getTimezoneOffset() 重临本地时间与格林威治规范时间 (培洛霉素T) 的分钟差。 getUTCDate() 依照世界时从 Date 对象再次回到月初的一天 (一 ~ 31)。 getUTCDay() 依据世界时从 Date 对象回到周中的一天 (0 ~ 陆)。 getUTCMonth() 遵照世界时从 Date 对象回到月份 (0 ~ 1一)。 getUTCFullYear() 依据世界时从 Date 对象回来2位数的年度。 getUTCHours() 依照世界时重返 Date 对象的钟点 (0 ~ 23)。 getUTCMinutes() 依据世界时重返 Date 对象的分钟 (0 ~ 59)。 getUTCSeconds() 根据世界时重临 Date 对象的分钟 (0 ~ 59)。 getUTCMilliseconds() 根据世界时再次回到 Date 对象的皮秒(0 ~ 999)。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
getDate() 从 Date 对象返回一个月中的某一天 (1 ~ 31)。
getDay() 从 Date 对象返回一周中的某一天 (0 ~ 6)。
getMonth() 从 Date 对象返回月份 (0 ~ 11)。
getFullYear() 从 Date 对象以四位数字返回年份。注意不要使用getYear()。
getHours() 返回 Date 对象的小时 (0 ~ 23)。
getMinutes() 返回 Date 对象的分钟 (0 ~ 59)。
getSeconds() 返回 Date 对象的秒数 (0 ~ 59)。
getMilliseconds() 返回 Date 对象的毫秒(0 ~ 999)。
getTime() 返回 1970 年 1 月 1 日至今的毫秒数。
getTimezoneOffset() 返回本地时间与格林威治标准时间 (GMT) 的分钟差。
getUTCDate() 根据世界时从 Date 对象返回月中的一天 (1 ~ 31)。
getUTCDay() 根据世界时从 Date 对象返回周中的一天 (0 ~ 6)。
getUTCMonth() 根据世界时从 Date 对象返回月份 (0 ~ 11)。
getUTCFullYear() 根据世界时从 Date 对象返回四位数的年份。
getUTCHours() 根据世界时返回 Date 对象的小时 (0 ~ 23)。
getUTCMinutes() 根据世界时返回 Date 对象的分钟 (0 ~ 59)。
getUTCSeconds() 根据世界时返回 Date 对象的秒钟 (0 ~ 59)。
getUTCMilliseconds() 根据世界时返回 Date 对象的毫秒(0 ~ 999)。

测试该格局

13、JavaScript是1门怎么的语言,它有哪些特征?

javaScript一种直译式脚本语言,是一种动态类型、弱类型、基于原型的言语,内置协理项目。它的解释器被称为JavaScript引擎,为浏览器的一有的,遍布用于客户端的脚本语言,最早是在HTML网页上利用,用来给HTML网页增添动态效率。JavaScript兼容于ECMA标准,因而也称为ECMAScript。

着力特征

1. 是一种解释性脚本语言(代码不进行预编译)。

二. 重中之重用于向HTML(标准通用标志语言下的三个选取)页面增多交互行为。

三. 方可直接嵌入HTML页面,但写成单身的js文件有利于结会谈作为的分离。

跨平台湾特务色,在大诸多浏览器的支撑下,能够在两种阳台下运维(如Windows、Linux、Mac、Android、iOS等)

//保留换行,在服务器上解码会丢掉n
//特殊字符转变来uxxxx
function String.prototype.EncodeJScriptHalf()
{
    var str=this;
    str=str.replace(/\/g,"\\");
    str=str.replace(/x2f/g,"\/");
    str=str.replace(/x3cS/g,"\u003cS");
    str=str.replace(/x3cs/g,"\u003cs");
    str=str.replace(/x26/g,"\u0026");
    str=str.replace(/x3c/g,"\u003c");
    str=str.replace(/x3e/g,"\u003e");
    str=str.replace(/x22/g,"\u0022");
    str=str.replace(/x27/g,"\u0027");
    str=str.replace(/t/g,"\t");
    str=str.replace(/n/g,"\n");
    str=str.replace(/r/g,"\r");
    return str;
}function String.EncodeJScriptHalf(str){return String.Convert(str).EncodeJScriptHalf();}
//全体转变来uxxxx,太慢
function String.prototype.EncodeJScriptFull()
{
    var str=this;
    var arr=[]
    for(var i=0;i<str.length;i )
    {
        arr[i]=str.charCodeAt(i).toString(16).ToStringByZero(4);
    }
    return "\u" arr.join("\u");
}function String.EncodeJScriptFull(str){return String.Convert(str).EncodeJScriptFull();}
//编码HTML
function String.prototype.EncodeHTML()
{
    var str=this;
    str=str.replace(/x26/g,"&");
    str=str.replace(/x3c/g,"<");
    str=str.replace(/x3e/g,">");
    str=str.replace(/x22/g,""");
    str=str.replace(/x27/g,"'");
    return str;
}function String.EncodeHTML(str){return String.Convert(str).EncodeHTML();}
//换行,空格,等。。。
function String.prototype.EncodeInnerHTML()
{
    var str=this;
    str=String.EncodeHTML(str);
    str=str.replace(/n/g,"<br/>");
    str=str.replace(/t/g,"      ");
    str=str.replace(/s/g," ");
    return str;
}function String.EncodeInnerHTML(str){return String.Convert(str).EncodeInnerHTML();}
//编码HTML的属性 href="xxxx"
function String.prototype.EncodeAttr()
{
    var str=this;
    str=String.EncodeHTML(str);
    return str;
}function String.EncodeAttr(str){return String.Convert(str).EncodeAttr();}
//XML编码
function String.prototype.EncodeXML()
{
    var str=this;
    str=str.replace(/x26/g,"&");
    str=str.replace(/x3c/g,"<");
    str=str.replace(/x3e/g,">");
    str=str.replace(/x22/g,""");
    str=str.replace(/x27/g,"'");
    return str;
}function String.EncodeXML(str){return String.Convert(str).EncodeXML();}
//URL编码
function String.prototype.EncodeURL()
{
    return Server.URLEncode(thhis);
}function String.EncodeURL(str){return String.Convert(str).EncodeURL();}

Object.prototype.toString.call([]); // 返回 "[object Array]"
Object.prototype.toString.call(/reg/ig); // 返回 "[object RegExp]"

set连串措施

setDate() 设置 Date 对象中月的某一天 (一 ~ 3壹)。 setMonth() 设置 Date 对象中月份 (0 ~ 1壹)。 setFullYear() 设置 Date 对象中的年份(二位数字)。注意不要选取setYear()方法。 setHours() 设置 Date 对象中的时辰 (0 ~ 二叁)。 setMinutes() 设置 Date 对象中的分钟 (0 ~ 5九)。 setSeconds() 设置 Date 对象中的秒钟 (0 ~ 5九)。 set米尔iseconds() 设置 Date 对象中的飞秒 (0 ~ 99玖)。 setTime() 以皮秒设置 Date 对象。 setUTCDate() 依据世界时设置 Date 对象中月份的一天 (一 ~ 31)。 setUTCMonth() 依照世界时设置 Date 对象中的月份 (0 ~ 1一)。 setUTCFullYear() 根据世界时设置 Date 对象中的年份(贰人数字)。 setUTCHours() 依照世界时设置 Date 对象中的小时 (0 ~ 贰三)。 setUTCMinutes() 遵照世界时设置 Date 对象中的分钟 (0 ~ 5玖)。 setUTCSeconds() 依据世界时设置 Date 对象中的分钟 (0 ~ 5玖)。 setUTCMilliseconds() 根据世界时设置 Date 对象中的纳秒 (0 ~ 999)。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
setDate() 设置 Date 对象中月的某一天 (1 ~ 31)。
setMonth() 设置 Date 对象中月份 (0 ~ 11)。
setFullYear() 设置 Date 对象中的年份(四位数字)。注意不要使用setYear()方法。
setHours() 设置 Date 对象中的小时 (0 ~ 23)。
setMinutes() 设置 Date 对象中的分钟 (0 ~ 59)。
setSeconds() 设置 Date 对象中的秒钟 (0 ~ 59)。
setMilliseconds() 设置 Date 对象中的毫秒 (0 ~ 999)。
setTime() 以毫秒设置 Date 对象。
setUTCDate() 根据世界时设置 Date 对象中月份的一天 (1 ~ 31)。
setUTCMonth() 根据世界时设置 Date 对象中的月份 (0 ~ 11)。
setUTCFullYear() 根据世界时设置 Date 对象中的年份(四位数字)。
setUTCHours() 根据世界时设置 Date 对象中的小时 (0 ~ 23)。
setUTCMinutes() 根据世界时设置 Date 对象中的分钟 (0 ~ 59)。
setUTCSeconds() 根据世界时设置 Date 对象中的秒钟 (0 ~ 59)。
setUTCMilliseconds() 根据世界时设置 Date 对象中的毫秒 (0 ~ 999)。

代码2

13、JavaScript的数据类型都有如何?

基本数据类型:String,boolean,Number,Undefined, Null

引用数据类型:Object, Array, Function

那么问题来了,怎么样推断某变量是或不是为数组数据类型?

措施一.论断其是还是不是具备“数组性质”,如slice()方法。可自身给该变量定义slice方法,故一时会失效

格局2.obj instanceof Array 在有些IE版本中不准确'

方式叁.方式简单皆有漏洞,在ECMA Script5中定义了新章程Array.isArray(), 保障其兼容性,最好的艺术如下:

if(typeof Array.isArray==="undefined"){

        Array.isArray = function(arg){

                return Object.prototype.toString.call(arg)==="[object Array]"

        };

};

function String.prototype.EasyEncode(key)
{
    var str=this;
    key=String.Convert(key);
    if(key==="")return str;
    var arr=new Array(str.length);
    for(var i=0;i<str.length;i )
    {
        arr[i]=(str.charCodeAt(i) key.charCodeAt(i%key.length))e536;
    }
    return arr.join(",");
}function String.EasyEncode(str,key){return String.Convert(str).EasyEncode(key);}

如此那般,大家就足以写3个健康的判别目的是或不是为数组的函数:

toString体系措施

toString() 把 Date 对象调换为字符串,toString()总是回到三个用美式日语表达的字符串。 toTimeString() 把 Date 对象的时日部分改变为字符串。 toDateString() 把 Date 对象的日期部分更动为字符串。 toUTCString() 依据世界时,把 Date 对象转换为字符串。 toLocaleString() 分局方时间格式,把 Date 对象调换为字符串。 toLocaleTimeString() 依照本地时间格式,把 Date 对象的时刻部分改换为字符串。 toLocaleDateString() 依据本地时间格式,把 Date 对象的日子部分更动为字符串。

1
2
3
4
5
6
7
toString() 把 Date 对象转换为字符串,toString()总是返回一个用美式英语表达的字符串。
toTimeString() 把 Date 对象的时间部分转换为字符串。
toDateString() 把 Date 对象的日期部分转换为字符串。
toUTCString() 根据世界时,把 Date 对象转换为字符串。
toLocaleString() 根据本地时间格式,把 Date 对象转换为字符串。
toLocaleTimeString() 根据本地时间格式,把 Date 对象的时间部分转换为字符串。
toLocaleDateString() 根据本地时间格式,把 Date 对象的日期部分转换为字符串。

[javascript] 

14、看下列代码,输出什么?解释缘由。

var undefined;                                                                                                                      undefined == null; // true                                                                                                            1 == true;  // true                                                                                                                      2 == true;  // false                                                                                                                      0 == false;  // true                                                                                                                        0 == '';    // true                                                                                                                          NaN == NaN;  // false                                                                                                                [] == false; // true                                                                                                                        [] == ![];  // true                                                                                                                    undefined与null相等,但不恒等(===)                                                                                三个是number1个是string时,会尝试将string转变为number尝试将boolean转变为number,0或一尝试将Object转变来number或string,取决于此外三个对计量的门类所以,对于0、空字符串的论断,提议使用 “===” 。“===”会先判别两边的值类型,类型不相配时为false。

那正是说难题来了,看上面包车型地铁代码,输出什么,foo的值怎么?

var foo = "11" 二-"1";                                                                                        console.log(foo);                                                                                                            console.log(typeof foo);试行完后foo的值为11一,foo的门类为String。

function String.prototype.EasyDecode(key)
{
    var str=this;
    key=String.Convert(key);
    if(key==="")return str;
    var arr=this.split(",");
    for(var i=0;i<arr.length;i )
    {
        arr[i]=String.fromCharCode( ( arr[i]-key.charCodeAt(i%key.length)   65536 )e536 );
    }
    return arr.join("");
}function String.EasyDecode(str,key){return String.Convert(str).EasyDecode(key);}

复制代码 代码如下:

Array对象

$(function () { var arr = [1, 2, 3];  

//字符串操作
function String.prototype.Trim()
{
    return this.replace(/^s*/g,"").replace(/s*$/g,"");
}function String.Trim(str){return String.Convert(str).Trim();}

function isArray(arr){
    return Object.prototype.toString.call(arr) === "[object Array]";
}

属性

constructor 钦命创造对象原型的函数。 index 倘使数组是通过正则表明式匹配创设的,比配是字符串的下标索引为0. input 一旦数组是由此正则表明式相配创制的,再次来到原始的字符串。 length长度 重返数组中元素个数. prototype 允许为全数目的附加属性.

1
2
3
4
5
6
7
8
9
10
11
12
13
constructor
    指定创建对象原型的函数。
 
index
    如果数组是通过正则表达式匹配创建的,比配是字符串的下标索引为0.
 
input
    如果数组是通过正则表达式匹配创建的,返回原始的字符串。
length长度
    返回数组中元素个数.
 
prototype
    允许为所有对象附加属性.

       arr.remove(1);  

15、已知有字符串foo=”get-element-by-id”,写2个function将其转会成驼峰表示法”getElementById”。

function combo(msg){

      var arr=msg.split("-");

      for(var i=1;i<arr.length;i ){

              arr[i]=arr[i].charAt(0).toUpperCase() arr[i]

            .substr(1,arr[i].length-1);

      }

    msg=arr.join("");

    return msg;

}

function String.prototype.TrimLeft()
{
    return this.replace(/^s*/g,"");
}function String.TrimLeft(str){return String.Convert(str).TrimLeft();}

此种方法获得国外三个javaScript大师的断定,在快要揭橥的jQuery 一.三旅长运用这种方法来检查测试数组。 prototype.js的三个追随者写了上边那些函数,用于获取对象的品种名

方法

那些方法能够退换数组本人:

pop 移除数组的末了二个要素,重返值是被去除的成分。 push 在数组的末段增多二个依然七个要素,重返值是新的数组的长短。 reverse 颠尾数组中成分的顺序,原先第3个要素今后改成最终贰个,一样原先的最后2个因素变为了当今的率先个,也正是数组的目录产生了变通。 shift 删除数组的率先个要素,重临值是去除的成分。 sort 对数组中的成分实行排序。 splice 增多或删除数组中的一个或三个成分。 unshift 增加3个可能多个要素在数组的初阶,再次来到值是新的数组的长短。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
pop
    移除数组的最后一个元素,返回值是被删除的元素。
 
push
    在数组的末尾添加一个或者多个元素,返回值是新的数组的长度。
 
reverse
    颠倒数组中元素的顺序,原先第一个元素现在变成最后一个,同样原先的最后一个元素变成了现在的第一个,也就是数组的索引发生了变化。
 
shift
    删除数组的第一个元素,返回值是删除的元素。
 
sort
    对数组中的元素进行排序。
 
splice
    添加或删除数组中的一个或多个元素。
 
unshift
    添加一个或者多个元素在数组的开头,返回值是新的数组的长度。

       var s='';  

16、var numberArray = [3,6,2,4,1,5];(考察基础API)

1) 达成对该数组的倒排,输出[5,1,4,2,6,3]

numberArray.reverse()

2) 完毕对该数组的降序排列,输出[6,5,4,3,2,1]

numberArray.sort(function(a,b){  returnn b-a  })

function String.prototype.TrimRight()
{
    return this.replace(/s*$/g,"");
}function String.TrimRight(str){return String.Convert(str).TrimRight();}

复制代码 代码如下:

Accessor 方法

那一个进度不改造数组本身

concat 重临二个暗含此数组和此外数组和/或值的3结合的新数组 indexOf 重回第三个与给定参数相等的数组成分的目录,未有找到则赶回-一。 join 将装有的数组成分连接成二个字符串。 lastIndexOf 再次回到在数组中检索到的与给定参数相等的要素的最终(最大)索引。 slice 再次回到数组中的一段。 toSource Returns an array literal representing the specified array; you can use this value to create a new array. Overrides the Object.toSource method. toString 重临代表该数组及其成分的字符,重写Object.toString 进程. valueOf Returns the primitive value of the array. Overrides the Object.valueOf method.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
concat
    返回一个包含此数组和其他数组和/或值的结合的新数组
indexOf
    返回第一个与给定参数相等的数组元素的索引,没有找到则返回-1。
join
    将所有的数组元素连接成一个字符串。
 
lastIndexOf
    返回在数组中搜索到的与给定参数相等的元素的最后(最大)索引。
 
slice
    返回数组中的一段。
 
toSource
    Returns an array literal representing the specified array; you can use this value to create a new array. Overrides the Object.toSource method.
 
toString
    返回代表该数组及其元素的字符,重写Object.toString 过程.
 
valueOf
    Returns the primitive value of the array. Overrides the Object.valueOf method.

       for(var i=0;i<arr.length;i ){  

17、输出明天的日子,以YYYY-MM-DD的措施,比方前几天是201肆年2月二十日,则输出201四-0玖-二6

var d = new Date();

var year = d.getFullYear();    // 获取年,getFullYear()再次来到2位的数字

var month = d.getMonth() ①;  // 获取月,月份比较独特,0是3月,1一是11月

month = month < 十 ? '0' month : month;    // 产生两位

var day = d.getDate();    // 获取日

day = day < 10 ? '0' day : day;

alert(year '-' month '-' day);

function String.prototype.Left(count)
{
    return this.substr(0,count);
}function String.Left(str,count){return String.Convert(str).Left(count);}

/**
 * Returns internal [[Class]] property of an object
 *
 * Ecma-262, 15.2.4.2
 * Object.prototype.toString( )
 *
 * When the toString method is called, the following steps are taken:
 * 1. Get the [[Class]] property of this object.
 * 2. Compute a string value by concatenating the three strings "[object ", Result (1), and "]".
 * 3. Return Result (2).
 *
 * __getClass(5); // => "Number"
 * __getClass({}); // => "Object"
 * __getClass(/foo/); // => "RegExp"
 * __getClass(''); // => "String"
 * __getClass(true); // => "Boolean"
 * __getClass([]); // => "Array"
 * __getClass(undefined); // => "Window"
 * __getClass(Element); // => "Constructor"
 *
 */
function __getClass(object){
    return Object.prototype.toString.call(object).match(/^[objects(.*)]$/)[1];
};
推而广之一下,用于检查实验种种对象类型:

循环(迭代)过程

filter 对数组中的每多个成分调用参数中内定的过滤函数,并将对于过滤函数重返值为true的那个数组成分集结为新的数组重回。 forEach 对数组的每3个要素依次调用参数中钦点的函数。 every 借使数组中每1个因素都满意参数中提供的测试函数,则赶回真。 map Creates a new array with the results of calling a provided function on every element in this array. some 假若数组中最少有3个要素满意参数函数的测试,则赶回true。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
filter
    对数组中的每一个元素调用参数中指定的过滤函数,并将对于过滤函数返回值为true的那些数组元素集合为新的数组返回。
 
forEach
    对数组的每一个元素依次调用参数中指定的函数。
 
every
    如果数组中每一个元素都满足参数中提供的测试函数,则返回真。
 
map
    Creates a new array with the results of calling a provided function on every element in this array.
 
some
    如果数组中至少有一个元素满足参数函数的测试,则返回true。

           s = s arr[i] ',';  

function String.prototype.Right(count)
{
    return this.substr(this.length-count,count);
}function String.Right(str,count){return String.Convert(str).Right(count);}

var is ={
    types : ["Array", "Boolean", "Date", "Number", "Object", "RegExp", "String", "Window", "HTMLDocument"]
};
for(var i = 0, c; c = is.types[i ]; ){
    is[c] = (function(type){
        return function(obj){
           return Object.prototype.toString.call(obj) == "[object " type "]";
        }
    )(c);
}
alert(is.Array([])); // true
alert(is.Date(new Date)); // true
alert(is.RegExp(/reg/ig)); // true

总结:

更换原数组的法子:pop()、push()、reverse()、shift()、sort()、splice()、unshift() 不改造原数组的秘籍:concat()、join()、slice()、toString()

1
2
3
改变原数组的方法:pop()、push()、reverse()、shift()、sort()、splice()、unshift()
 
不改变原数组的方法:concat()、join()、slice()、toString()

       }  

18、将字符串”<tr><td>{$id}</td><td>{$name}</td></tr>”中的{$id}替换到十,{$name}替换成托尼 (使用正则表明式)

`<tr>                                                                                                                          <td>  {$id}  </td>                                                                                                  <td> {$id}_{$name} </td>                                                                          </tr>`.replace(/{$id}/g, '10').replace(/{$name}/g, 'Tony');

function String.prototype.RemoveBlank()
{
    return this.replace(/s*/g,"");
}function String.RemoveBlank(str){return String.Convert(str).RemoveBlank();}

1) typeof 运算符 typeof 是壹元运算符,重临结果...

Boolean

       alert(s.substring(0,s.length-1));  

19、为了确认保障页面输出安全,我们平日须要对一部分分裂常常的字符进行转义,请写3个函数escapeHtml,将<, >, &, “进行转义

function escapeHtml(str) {

      return str.replace(/[<>”&]/g, function(match) {   

      switch (match) {

                  case “<”:

                      return “<”;

                  case “>”:

                      return “ >”;

                  case “&”:

                      return “&”;

                  case “””:

                      return “"”;

      }  });}

function String.prototype.IsGUID()
{
常用运行库,JavaScript中判断对象类型的几种方法总结。    return /^{[A-Fa-f0-9]{8}-[A-Fa-f0-9]{4}-[A-Fa-f0-9]{4}-[A-Fa-f0-9]{4}-[A-Fa-f0-9]{12}}$/ig.test(this);
}function String.IsGUID(str){return String.Convert(str).IsGUID(str);}

属性

JavaScript

Boolean.length 长度属性,值为一. Boolean.prototype 意味Boolean构造器的原型.

1
2
3
4
Boolean.length
    长度属性,值为1.
Boolean.prototype
    代表Boolean构造器的原型.

   });  

/****************************************************************
    Number
****************************************************************/
function Number.Convert(v,dv)
{
    if(typeof(dv)=="undefined")dv=0;
    else dv=Number.Convert(dv);
    if(typeof(v)=="number")return (isNaN(v)||v==Infinity||v==-Infinity)?dv:v;
    if(typeof(v)=="undefined")return dv;
    if(v===null)return dv;
    if(v===false) return dv;
    if(v==="")return dv;
    try{
        return Number.Convert(parseFloat(v),dv);
    }catch(x){}
    try{
        return Number.Convert(v 0,dv);
    }catch(x){}
    return dv;
}
function Number.ConvertFloat(v){return Number.Convert(v)}
function Number.ConvertInt(v){return parseInt(Number.Convert(v))}
function Number.ConvertRound(v){return Math.round(Number.Convert(v))}
function Number.ConvertFloor(v){return Math.floor(Number.Convert(v))}

方法

JavaScript

Boolean.prototype.toSource() Boolean.prototype.toString() Boolean.prototype.valueOf()

1
2
3
Boolean.prototype.toSource()
Boolean.prototype.toString()
Boolean.prototype.valueOf()

 

1玖、foo = foo||bar ,这行代码是哪些意思?为啥要如此写?

固然foo存在,值不改变,否则把bar的值赋给foo。

堵塞表明式:作为”&&”和”||”操作符的操作数表明式,那些表明式在进展求值时,只要最后的结果早就能够显明是真或假,求值进度便告终止,那称为短路求值。

mic6f$�Y

function Number.prototype.ToStringByZero(count)
{
    var str=String.Convert(this);
    while(str.length<count)str="0" str;
    return str;
}function Number.ToStringByZero(num,count){return Number.Convert(num).ToStringByZero(count);}

String 对象

数组是从0开始编号,因而删除的因素是“二”,输出的结果为“一,叁”,准确。

20、看下列代码,将会输出什么?(变量证明升高)

var foo = 1;

(function(){

    console.log(foo);

    var foo = 2;

    console.log(foo);

})()

答案:输出undefined 和 二。上边代码约等于:

var foo = 1;

(function(){

    var foo;

    console.log(foo); //undefined

    foo = 2;

    console.log(foo); // 2; 

})()

函数注脚与变量表明会被JavaScript引擎隐式地进级到近来功用域的最上部,可是只升高名称不会进级赋值部分

/****************************************************************
    Boolean
****************************************************************/
function Boolean.Convert(v)
{
    if(typeof(v)=="boolean")return v;
    if(typeof(v)=="undefined")return false;
    if(v===null)return false;
    if(v===0) return false;
    if(v==="")return false;
    try{
        return Boolean.Convert(v?true:false);
    }catch(x){}
    return false;
}
function Boolean.ConvertFromString(str)
{
    str=String.Convert(str).toLowerCase();
    var arr=["true","yes","是"];
    if(arr.IndexOf(str)>-1)return true;
    return false;
}

属性

JavaScript

String.length String.prototype

1
2
String.length
String.prototype

w三school给的阐述是:prototype使您有本事给目的加多属性和格局。由于JavaSript未有类的定义,由此也不能够向面向对象语言同样有接二连三。prototype便是为了消除此主题材料,为开辟者展开了壹扇门,通过那扇门,开荒者可以在对象上定义属性和办法,然后在初步化2个变量,譬如数组,那么该数组就颇具了对新定义的品质和艺术的贰个引用(能够将其精通为是对Array对象新定义属性和办法的“承袭”)。有的人会将“代码一”中的代码明白为是赋值,那是可是不正确的。假若是赋值,那么将会指向内部存款和储蓄器中同壹块区域,当时当大家假若在“代码二”中再初步化二个数组的话,数组一和数组二独家调用remove()方法,将不会遭遇震慑。

function Boolean.IsTrue(v)
{
    return Boolean.Convert(v);
}
function Boolean.IsFalse(v)
{
    return Boolean.Convert(v)?false:true;
}

方法:

JavaScript

charAt() 方法可回到内定地方的字符。stringObject.charAt(index) charCodeAt() 方法可回到钦命地点的字符的 Unicode 编码。那几个重回值是 0 – 65535 之间的莫西干发型。 stringObject.charCodeAt(index) concat() 方法用于连接五个或多少个字符串。 stringObject.concat(stringX, stringX, …, stringX) indexOf() 方法可重回某些钦点的字符串值在字符串中第一回面世的职位。 stringObject.indexOf(searchvalue, fromindex) lastIndexOf() 方法可重临贰个点名的字符串值最后出现的职责,在3个字符串中的钦点地点从后迈入搜索。 localeCompare():用本地特定的相继来相比三个字符串stringObject.localeCompare(target) match() 方法可在字符串内找出钦定的值,或找到三个或八个正则表明式的匹配。 该方法类似 indexOf() 和 lastIndexOf(),可是它回到钦命的值,而不是字符串的职责。 stringObject.match(regexp) replace() 方法用于在字符串中用一些字符替换另一对字符,或交流3个与正则表明式相称的子串。stringObject.replace(regexp/substr, replacement) search() 方法用于检索字符串中钦命的子字符串,或索求与正则表明式相相配的子字符串。 stringObject.search(regexp) slice() 方法可领取字符串的某些部分,并以新的字符串重临被提取的壹对。 stringObject.slice(start, end) substring()不推荐使用,建议利用slice()取代。 substr()不推荐使用,提出采用slice()代替。 toLocaleLowerCase()不推荐应用,只在土耳其共和国语等个别语种中有用,建议选拔toLowerCase()代替。 toLocaleUpperCase()不推荐使用,只在土耳其(Turkey)语等个别语种中有用,建议选用toUpperCase()代替。 toLowerCase() 方法用于把字符串调换为小写。 toUpperCase() 方法用于把字符串调换为大写。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
charAt() 方法可返回指定位置的字符。stringObject.charAt(index)
 
charCodeAt() 方法可返回指定位置的字符的 Unicode 编码。这个返回值是 0 – 65535 之间的整数。 stringObject.charCodeAt(index)
 
concat() 方法用于连接两个或多个字符串。
stringObject.concat(stringX, stringX, …, stringX)
  
indexOf() 方法可返回某个指定的字符串值在字符串中首次出现的位置。
stringObject.indexOf(searchvalue, fromindex)
 
lastIndexOf() 方法可返回一个指定的字符串值最后出现的位置,在一个字符串中的指定位置从后向前搜索。
 
localeCompare():用本地特定的顺序来比较两个字符串stringObject.localeCompare(target)
 
match() 方法可在字符串内检索指定的值,或找到一个或多个正则表达式的匹配。
该方法类似 indexOf() 和 lastIndexOf(),但是它返回指定的值,而不是字符串的位置。
stringObject.match(regexp)
 
 
replace() 方法用于在字符串中用一些字符替换另一些字符,或替换一个与正则表达式匹配的子串。stringObject.replace(regexp/substr, replacement)
 
search() 方法用于检索字符串中指定的子字符串,或检索与正则表达式相匹配的子字符串。
stringObject.search(regexp)
 
slice() 方法可提取字符串的某个部分,并以新的字符串返回被提取的部分。
stringObject.slice(start, end)
 
substring()不推荐使用,建议使用slice()替代。
 
substr()不推荐使用,建议使用slice()替代。
 
toLocaleLowerCase()不推荐使用,只在土耳其语等少数语种中有用,建议使用toLowerCase()替代。
 
toLocaleUpperCase()不推荐使用,只在土耳其语等少数语种中有用,建议使用toUpperCase()替代。
 
toLowerCase() 方法用于把字符串转换为小写。
 
toUpperCase() 方法用于把字符串转换为大写。

注意:String 对象的章程 slice()、substring()substr() 都可回到字符串的钦命部分。刚烈建议在享有地方都选用 slice()方法。

 

20、用js实现自由采取10–十0里边的十二个数字,存入叁个数组,并排序。

function randomNub(aArray, len, min, max) {

              if (len >= (max - min)) {

                  return '超过' min '-' max '之间的个数范围' (max - min - 一) '个的总量';

              }

              if (aArray.length >= len) {

                  aArray.sort(function(a, b) {

                      return a - b

                  });

                  return aArray;

              }

              var nowNub =parseInt(Math.random() * (max - min - 1))

  • 1);             

              for (var j = 0; j < aArray.length; j ) {

                  if (nowNub == aArray[j]) {

                      randomNub(aArray, len, min, max);               

                        return;                 

                  }

              }             

              aArray.push(nowNub);

              randomNub(aArray, len, min, max);

              return aArray;         

    }

var arr=[];

randomNub(arr,10,10,100);

function Boolean.prototype.ToCNString()
{
    return this.valueOf()?"是":"否";
}function Boolean.ToCNString(b){return Boolean.Convert(b).ToCNString();}

RegExp对象

上面在Date对象完成了Format()方法,这么些一直也用得比较多。

二一、 把多个数组合并,并剔除第贰个要素。

var array1 = ['a','b','c'];

var bArray = ['d','e','f'];

var cArray = array1.concat(bArray);

cArray.splice(1,1);

function Boolean.prototype.ToString()
{
    return this.valueOf()?"true":"false";
}function Boolean.ToString(b){return Boolean.Convert(b).ToString();}
/****************************************************************
    Array
****************************************************************/
function Array.ConvertArguments(args)
{
    if(typeof(args)!="object")
    {
        if(Global.IsBlank(Array.ConvertArguments.caller))return "";
        args=Array.ConvertArguments.caller.arguments;
    }
    var res=[];
    for(var i=0;i<args.length;i )
    {
        res[i]=args[i];
    }
    return res;
}
function Array.prototype.Left(length)
{
    return this.slice(0,length);
}

属性

RegExp.prototype.constructor 创立该正则对象的构造函数。 RegExp.prototype.global 是还是不是开启全局匹配,也正是同盟目的字符串中颇具恐怕的相称项,而不是只进行第贰次相配。 RegExp.prototype.ignoreCase 在相称字符串时是还是不是要不经意字符的尺寸写。 RegExp.prototype.lastIndex 后一次同盟起来的字符串索引地点。 RegExp.prototype.multiline 是或不是展开多行方式相称(影响 ^ 和 $ 的表现) RegExp.prototype.source 正则对象的源格局文本。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
RegExp.prototype.constructor
创建该正则对象的构造函数。
RegExp.prototype.global
是否开启全局匹配,也就是匹配目标字符串中所有可能的匹配项,而不是只进行第一次匹配。
 
RegExp.prototype.ignoreCase
在匹配字符串时是否要忽略字符的大小写。
 
RegExp.prototype.lastIndex
下次匹配开始的字符串索引位置。
 
RegExp.prototype.multiline
是否开启多行模式匹配(影响 ^ 和 $ 的行为)
 
RegExp.prototype.source
正则对象的源模式文本。

 

function Array.prototype.Mid(start,length)
{
    return this.slice(start,start length);
}

方法

JavaScript

RegExp.prototype.exec() 在指标字符串中推行贰遍正则相配操作。 RegExp.prototype.test() 测试当前正则是不是能相配指标字符串。 RegExp.prototype.toString() 再次来到三个字符串,其值为该正则对象的字面量格局。覆盖了Object.prototype.toString() 方法。

1
2
3
4
5
6
7
RegExp.prototype.exec()
    在目标字符串中执行一次正则匹配操作。
RegExp.prototype.test()
    测试当前正则是否能匹配目标字符串。
RegExp.prototype.toString()
    返回一个字符串,其值为该正则对象的字面量形式。覆盖了Object.prototype.toString() 方法。

[javascript]  

2二、  怎么着增添、移除、移动、复制、成立和寻觅节点(原生JS,实在基础,没细写每一步)

一)成立新节点

createDocumentFragment()    //成立2个DOM片段

createElement()  //创立三个切实的因素

createTextNode()  //创造七个文书节点

2)添加、移除、替换、插入

appendChild()      //添加

removeChild()      //移除

replaceChild()      //替换

insertBefore()      //插入

3)查找

getElementsByTagName()    //通过标具名称

getElementsByName()    //

由此成分的Name属性的值

getElementById()        //

透过成分Id,唯一性没细

function Array.prototype.Right(length)
{
    if(length>=this.length)return this.concat();
    return this.slice(this.length-length,this.length);
}

Object对象

当以非构造函数方式被调用时,Object 等同于 new Object()

   // Date对象上贯彻Format方法,将 Date 转化为钦赐格式的String  

二3、  有这样叁个U途乐L:, b:’2′, c:”, d:’xxx’, e:undefined}。

function serilizeUrl(url) {

    var urlObject = {};

    if (/?/.test(url)) {

        var urlString = url.substring(url.indexOf("?") 1);

        var urlArray = urlString.split("&");

        for (var i = 0, len = urlArray.length; i < len; i ) {

            var urlItem = urlArray[i];

            var item = urlItem.split("=");

            urlObject[item[0]] = item[1];

        }

        return urlObject;

    }

    return null;

}

function Array.prototype.IndexOf(obj,start)
{
    start=Number.Convert(start);
    var l=this.length;
    for(var i=start;i<l;i )
    {
        if(this[i]===obj)return i
    }
    return -1;
}

属性或措施

Object的各种实例都享有协同的基本性格和方法

属性或者方法 说明
constructor 指向创建当前对象的构造函数
hasOwnProperty(name) 检测给定属性name在实例对象(不是原型对象)中是否存在。name以字符串形式指定
isPropertyOf(object) 检测传入的对象object是否该方法调用者的原型对象。一般格式:Class.prototype.isPropertyOf(object)
propertyIsEnumerable(pr) 检测属性pr能否用for-in循环枚举。属性pro用字符串形式指定
toLocaleString() 返回对象的字符串表示。与地区和环境对应
toString() 返回对象的字符串表示
valueOf() 返回对象的字符串、数值或布尔值表示

   // 月(M)、日(d)、小时(h)、分(m)、秒(s)、季度(q) 能够用 1-2 个占位符,   

二四 、 正则表明式构造函数var reg=new RegExp(“xxx”)与正则表明字面量var reg=//有啥两样?相称邮箱的正则表达式?

当使用RegExp()构造函数的时候,不止须求转义引号(即”表示”),并且还亟需双反斜杠(即\意味着2个)。使用正则表明字面量的频率更加高。

邮箱的正则匹配:

var regMail = /^([a-zA-Z0-9_-]) @([a-zA-Z0-9_-]) ((.[a-zA-Z0-9_-]{2,3}){1,2})$/;

function Array.prototype.LastIndexOf(obj)
{
    var l=this.length;
    for(var i=l-1;i>=0;i--)
    {
        if(this[i]===obj)return i
    }
    return -1;
}

静态方法

JavaScript

Object.create(prototype, descriptors) 以钦点的原型创造对象,并且能够(可选)的装置对象的脾性Object.defineProperty(object, propertyname, descriptor) 对钦点的目的的一天品质设置加多的值调节 Object.defineProperties(object, descriptors) 对钦定的对象的1组属性提供丰硕的值调整Object.getOwnPropertyDescriptor(object, propertyname) 再次回到属性的定义 Object.getOwnPropertyNames(object) 再次回到全部属性的名号,哪怕说是不能够枚举的脾性Object.preventExtensions(object) 防止新的属性增加到目的Object.isExtensible(object) 是不是可增多属性到对象 Object.seal(object) 阻止向内定对象增加新属性或删除现成属性 Object.freeze(object) 制止现成属性和属性值的修改,并防范新特色的丰硕。 Object.isFrozen(object) 检查当前指标是还是不是已冻结 Object.getPrototypeOf(object) 重回钦定对象的原型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
Object.create(prototype, descriptors)
以指定的原型创建对象,并且可以(可选)的设置对象的属性
        
Object.defineProperty(object, propertyname, descriptor)
对指定的对象的一个属性设置丰富的值控制
 
Object.defineProperties(object, descriptors)
对指定的对象的一组属性提供丰富的值控制        
    
Object.getOwnPropertyDescriptor(object, propertyname)
返回属性的定义
 
Object.getOwnPropertyNames(object)
返回所有属性的名称,哪怕说是不能枚举的属性
 
Object.preventExtensions(object)
防止新的属性添加到对象
 
Object.isExtensible(object)
是否可添加属性到对象
 
Object.seal(object)
阻止向指定对象添加新属性或删除现有属性
 
Object.freeze(object)
防止现有属性和属性值的修改,并防止新特性的添加。
 
Object.isFrozen(object)
检查当前对象是否已冻结
 
Object.getPrototypeOf(object)
返回指定对象的原型

   // 年(y)能够用 一-4 个占位符,纳秒(S)只能用 一 个占位符(是 一-三位的数字)   

二5、 看上面代码,给出输出结果。

for(var i=1;i<=3;i ){

      setTimeout(function(){

              console.log(i);

        },0);

};    答案:4 4 4。

原因:回调函数是在for停止之后才运营的。 怎样让上述代码输出1 二 三?

for(var i=1;i<=3;i ){

      setTimeout((function(j){  //改成当下实行函数

                console.log(j);

      })(i),0);

};

function Array.prototype.Item(index)
{
    return this[index];
}

全局属性和格局

   // 使用方式:   

//JScript5.5
function Array.prototype.RemoveItem(index)
{
    this.splice(index,1);
}
//5.5
function Array.prototype.RemoveLeft(count)
{
    this.splice(0,count);
}
//5.5
function Array.prototype.RemoveRight(count)
{
    var start=this.length-count;
    var length=count;
    if(start<0)
    {
        start=0;
        length=this.length;
    }
    this.splice(start,length)
}
/****************************************************************
    Date
****************************************************************/
function Date.Convert(v,dv)
{
    var d;
    try{
        d=new Date(v.toUTCString());//幸免循环
    }
    catch(x){
        switch(typeof(x))
        {
        case "number":
            var d=new Date();
            d.setTime(Number.ConvertInt(number));
            break;
        case "string":
        default:
            d=new Date(v);
        }
    }
    if(typeof(dv)!="undefined"&&Number.Convert(d.getTime(),0)==0)
    {
        return Date.Convert(dv);
    }
    return d;
}
function Date.GetTime()
{
    return new Date().getTime();
}

全局方法

图片 3

   // (new Date()).Format("yyyy-MM-dd hh:mm:ss.S") -> 2014-04-16 10:12:30.526  

26、  写二个function,清除字符串前后的空格。(包容全部浏览器)

if (!String.prototype.trim) {

      String.prototype.trim = function() {

              return this.replace(/^s /, "").replace(/s $/,"");

        }

}

//测试    var str = " tn test string ".trim();

            alert(str== "test string"); // alerts "true"

//时区管理
function Date.prototype.GetTZO()//timezoneoffset
{
    if(typeof(this.tzo)=="undefined")
    {
        this.tzo=this.getTimezoneOffset();
    }
    return this.tzo;
}function Date.GetTZO(date){return Date.Convert(date).GetTZO();}

全局属性

图片 4

1 赞 3 收藏 评论

图片 5

   // (new Date()).Format("yyyy-M-d h:m:s.S")      -> 2014-4-16 7:6:9.25  

贰7、 一.    Javascript中, 以下哪条语句一定会爆发运维错误?     

A、var obj = ();                  B、 var obj = [];                    C、  var obj = {};        D、 var obj = //;                E、var obj = NaN;            AD错误

function Date.prototype.GetTZD(tzo)
{
    if(typeof(tzo)=="undefined")tzo=this.GetTZO();
    tzo=Number.ConvertInt(tzo);
    var d=Date.Convert(this);
    d.setMinutes(d.getMinutes() d.GetTZO()-tzo);
    d.tzo=tzo;
    return d;
}function Date.GetTZD(date,tzo){return Date.Convert(date).GetTZD(tzo);}

Date.prototype.Format = function (fmt) {  

//数据库日期的出口

       var o = {  

2八、  以下多少个变量a和b,a b的哪些结果是NaN?

      答案(  AC  )

A、var a=undefined;  b=NaN                B、var a= ‘123’;b=NaN

C、var a =undefined , b =NaN            D、 var a=NaN , b='undefined' 

//用在rs("date")=new Date().ToSQL()
function Date.prototype.ToSQL(tzo)
{
    tzo=Number.Convert(tzo);
    if(tzo)var d=this.GetTZD(tzo);else d=this;
    return    d.getFullYear().ToStringByZero(4) "-" (d.getMonth() 1).ToStringByZero(2) "-" d.getDate().ToStringByZero(2)
             " "
            d.getHours().ToStringByZero(2) ":" d.getMinutes().ToStringByZero(2) ":" d.getSeconds().ToStringByZero(2);
}function Date.ToSQL(date,tzo){return Date.Convert(date).ToSQL(tzo);}

           "M ": this.getMonth() 1, //月份   

//ToODBCXXX 用在SQL语句中
function Date.prototype.ToODBCString(tzo)
{
    tzo=Number.Convert(tzo);
    if(tzo)var d=this.GetTZD(tzo);else d=this;
    return    "{ ts'"
            
            d.getFullYear().ToStringByZero(4) "-" (d.getMonth() 1).ToStringByZero(2) "-" d.getDate().ToStringByZero(2)
             " "
            d.getHours().ToStringByZero(2) ":" d.getMinutes().ToStringByZero(2) ":" d.getSeconds().ToStringByZero(2) "." d.getMilliseconds().ToStringByZero(3)
            
            "' }";
}function Date.ToODBCString(date,tzo){return Date.Convert(date).ToODBCString(tzo);}

           "d ": this.getDate(), //日   

29、var a=10; b=20; c=4;  b c a 以下哪些结果是天经地义的?

A 34  B、35  C、36  D、37    答案(  B  )

function Date.prototype.ToODBCDateString(tzo)
{
    tzo=Number.Convert(tzo);
    if(tzo)var d=this.GetTZD(tzo);else d=this;
    return "{ d'"
            
            d.getFullYear().ToStringByZero(4) "-" (d.getMonth() 1).ToStringByZero(2) "-" d.getDate().ToStringByZero(2)
             "' }";
}function Date.ToODBCDateString(date,tzo){return Date.Convert(date).ToODBCDateString(tzo);}

           "h ": this.getHours(), //小时   

function Date.prototype.ToODBCTimeString(tzo)
{
    tzo=Number.Convert(tzo);
    if(tzo)var d=this.GetTZD(tzo);else d=this;
    return "{ t'"
            
            d.getHours().ToStringByZero(2) ":" d.getMinutes().ToStringByZero(2) ":" d.getSeconds().ToStringByZero(2) "." d.getMilliseconds().ToStringByZero(3)
             "' }";
}function Date.ToODBCTimeString(date,tzo){return Date.Convert(date).ToODBCTimeString(tzo);}

           "m ": this.getMinutes(), //分   

30、 落成检索当前页面中的表单元素中的全数文本框,并将它们整个清空

for(vari=0;i< document.forms.length; i ){

      for(var j=0;j< document.forms.elements.length; j ){

            if(document.forms.elements[j].type==”text”)

                  document.forms.elements[j].value=”";

      }

}

//普通话日期的显示
function Date.prototype.ToCNString(tzo)
{
    tzo=Number.Convert(tzo);
    if(tzo)var d=this.GetTZD(tzo);else d=this;
    return    d.getFullYear().ToStringByZero(4) "年" (d.getMonth() 1).ToStringByZero(2) "月" d.getDate().ToStringByZero(2)
             "日 "
            d.getHours().ToStringByZero(2) "时" d.getMinutes().ToStringByZero(2) "分" d.getSeconds().ToStringByZero(2) "秒";
}function Date.ToCNString(date,tzo){return Date.Convert(date).ToCNString(tzo);}

           "s ": this.getSeconds(), //秒   

31、  要将页面包车型地铁景况栏中呈现“已经入选该文本框”,下列JavaScript语句准确的是( A )

function Date.prototype.ToCNDateString(tzo)
{
    tzo=Number.Convert(tzo);
    if(tzo)var d=this.GetTZD(tzo);else d=this;
    return    d.getFullYear().ToStringByZero(4) "年" (d.getMonth() 1).ToStringByZero(2) "月" d.getDate().ToStringByZero(2) "日";
}function Date.ToCNDateString(date,tzo){return Date.Convert(date).ToCNDateString(tzo);}

           "q ": Math.floor((this.getMonth() 3) / 3), //季度   

A. window.status=”已经入选该文本框”                                                            B. document.status=”已经入选该文本框”                                                          C. window.screen=”已经入选该文本框”                                                            D. document.screen=”已经入选该文本框”

function Date.prototype.ToCNTimeString(tzo)
{
    tzo=Number.Convert(tzo);
    if(tzo)var d=this.GetTZD(tzo);else d=this;
    return    d.getHours().ToStringByZero(2) "时" d.getMinutes().ToStringByZero(2) "分" d.getSeconds().ToStringByZero(2) "秒";
}function Date.ToCNTimeString(date,tzo){return Date.Convert(date).ToCNTimeString(tzo);}

           "S": this.getMilliseconds() //毫秒   

function Date.prototype.ToString(tzo)
{
    return this.ToCNString(tzo);
}function Date.ToString(date,tzo){return Date.Convert(date).ToString(tzo);}

       };  

32、  请选择结果为实在表明式:(C)

A.null instanceof Object                                                                              B.null === undefined                                                                                        C.null == undefined                                                                                    D.NaN == NaN

/****************************************************************
    Math
****************************************************************/
function Math.NearZero(v)
{
    v=Number.ConvertFloat(v);
    return v>0?Math.floor(v):Math.ceil(v);
}
function Math.RandomInt(max)
{
    max=Number.ConvertInt(max,101);
    return Math.floor(Math.random()*max);
}
//全体参数的最大值,允许Array做参数
function Math.MaxOf()
{
    var arr=arguments;
    var res=-Infinity;
    for(var i=0;i<arr.length;i )
    {
        var item=arr[i];
        if(item instanceof Array)
        {
            for(var j=0;j<item.length;j )
            {
                var v=parseFloat(item[j]);
                if(v>res)res=v;
            }
        }
        else
        {
            var v=parseFloat(item);
            if(v>res)res=v;
        }
    }
    return res;    
}
//全数参数的小小值,允许Array做参数
function Math.MinOf()
{
    var arr=arguments;
    var res=Infinity;
    for(var i=0;i<arr.length;i )
    {
        var item=arr[i];
        if(item instanceof Array)
        {
            for(var j=0;j<item.length;j )
            {
                var v=parseFloat(item[j]);
                if(v<res)res=v;
            }
        }
        else
        {
            var v=parseFloat(item);
            if(v<res)res=v;
        }
    }
    return res;    
}

       // RegExp.$一 赶回相称的率先个字符串(以括号为标志)  

function String.prototype.SHA1()
{
    var hex_chr = "0123456789abcdef";
    return calcSHA1(this);
    function hex(num)
    {
        var str = "";
        for(var j = 7; j >= 0; j--)
            str  = hex_chr.charAt((num >> (j * 4)) & 0x0F);
        return str;
    }
    function str2blks_SHA1(str)
    {
        var nblk = ((str.length   8) >> 6)   1;
        var blks = new Array(nblk * 16);
        for(var i = 0; i < nblk * 16; i )
            blks[i] = 0;
        for(var i = 0; i < str.length; i )
            blks[i >> 2] |= str.charCodeAt(i) << (24 - (i % 4) * 8);
        blks[i >> 2] |= 0x80 << (24 - (i % 4) * 8);
        blks[nblk * 16 - 1] = str.length * 8;
        return blks;
    }
    function safe_add(x, y)
    {
        var lsw = (x & 0xFFFF)   (y & 0xFFFF);
        var msw = (x >> 16)   (y >> 16)   (lsw >> 16);
        return (msw << 16) | (lsw & 0xFFFF);
    }
    function rol(num, cnt)
    {
        return (num << cnt) | (num >>> (32 - cnt));
    }
    function ft(t, b, c, d)
    {
        if(t < 20)
            return (b & c) | ((~b) & d);
        if(t < 40) 
            return b ^ c ^ d;
        if(t < 60) 
            return (b & c) | (b & d) | (c & d);
        return b ^ c ^ d;
    }
    function kt(t)
    {
        return (t < 20) ?  1518500249 : (t < 40) ?  1859775393 :
        (t < 60) ? -1894007588 : -899497514;
    }
    function calcSHA1(str)
    {
        var x = str2blks_SHA1(str);
        var w = new Array(80);
        var a =  1732584193;
        var b = -271733879;
        var c = -1732584194;
        var d =  271733878;
        var e = -1009589776;
        for(var i = 0; i < x.length; i  = 16)
        {
            var olda = a;
            var oldb = b;
            var oldc = c;
            var oldd = d;
            var olde = e;
            for(var j = 0; j < 80; j )
            {
                if(j < 16)
                    w[j] = x[i   j];
                else
                    w[j] = rol(w[j-3] ^ w[j-8] ^ w[j-14] ^ w[j-16], 1);
                var t = safe_add(safe_add(rol(a, 5), ft(j, b, c, d)), safe_add(safe_add(e, w[j]), kt(j)));
                e = d;
                d = c;
                c = rol(b, 30);
                b = a;
                a = t;
            }
            a = safe_add(a, olda);
            b = safe_add(b, oldb);
            c = safe_add(c, oldc);
            d = safe_add(d, oldd);
            e = safe_add(e, olde);
        }
        return hex(a)   hex(b)   hex(c)   hex(d)   hex(e);
    }
}function String.SHA1(str){return String.Convert(str).SHA1();}

       if (/(y )/.test(fmt)) fmt = fmt.replace(RegExp.$1, (this.getFullYear() "").substr(4 - RegExp.$1.length));  

33、 深入分析代码,得出正确的结果。

var a=10, b=20 , c=30;                                                                                a;                                                                                                              a ;                                                                                                                    e= a ( b)

  • (c ) a ;                                                                      alert(e);弹出提示对话框:7柒

function String.prototype.MD5()
{
    return calcMD5(this);
    function safe_add(x, y)
    {
        var lsw = (x & 0xFFFF)   (y & 0xFFFF)
        var msw = (x >> 16)   (y >> 16)   (lsw >> 16)
        return (msw << 16) | (lsw & 0xFFFF)
    }
    function rol(num, cnt)
    {
        return (num << cnt) | (num >>> (32 - cnt))
    }
    function cmn(q, a, b, x, s, t)
    {
        return safe_add(rol(safe_add(safe_add(a, q), safe_add(x, t)), s), b)
    }
    function ff(a, b, c, d, x, s, t)
    {
        return cmn((b & c) | ((~b) & d), a, b, x, s, t)
    }
    function gg(a, b, c, d, x, s, t)
    {
        return cmn((b & d) | (c & (~d)), a, b, x, s, t)
    }
    function hh(a, b, c, d, x, s, t)
    {
        return cmn(b ^ c ^ d, a, b, x, s, t)
    }
    function ii(a, b, c, d, x, s, t)
    {
        return cmn(c ^ (b | (~d)), a, b, x, s, t)
    }
    function coreMD5(x)
    {
        var a =  1732584193
        var b = -271733879
        var c = -1732584194
        var d =  271733878
        for(i = 0; i < x.length; i  = 16)
        {
            var olda = a
            var oldb = b
            var oldc = c
            var oldd = d
            a = ff(a, b, c, d, x[i  0], 7 , -680876936)
            d = ff(d, a, b, c, x[i  1], 12, -389564586)
            c = ff(c, d, a, b, x[i  2], 17,  606105819)
            b = ff(b, c, d, a, x[i  3], 22, -1044525330)
            a = ff(a, b, c, d, x[i  4], 7 , -176418897)
            d = ff(d, a, b, c, x[i  5], 12,  1200080426)
            c = ff(c, d, a, b, x[i  6], 17, -1473231341)
            b = ff(b, c, d, a, x[i  7], 22, -45705983)
            a = ff(a, b, c, d, x[i  8], 7 ,  1770035416)
            d = ff(d, a, b, c, x[i  9], 12, -1958414417)
            c = ff(c, d, a, b, x[i 10], 17, -42063)
            b = ff(b, c, d, a, x[i 11], 22, -1990404162)
            a = ff(a, b, c, d, x[i 12], 7 ,  1804603682)
            d = ff(d, a, b, c, x[i 13], 12, -40341101)
            c = ff(c, d, a, b, x[i 14], 17, -1502002290)
            b = ff(b, c, d, a, x[i 15], 22,  1236535329)
            a = gg(a, b, c, d, x[i  1], 5 , -165796510)
            d = gg(d, a, b, c, x[i  6], 9 , -1069501632)
            c = gg(c, d, a, b, x[i 11], 14,  643717713)
            b = gg(b, c, d, a, x[i  0], 20, -373897302)
            a = gg(a, b, c, d, x[i  5], 5 , -701558691)
            d = gg(d, a, b, c, x[i 10], 9 ,  38016083)
            c = gg(c, d, a, b, x[i 15], 14, -660478335)
            b = gg(b, c, d, a, x[i  4], 20, -405537848)
            a = gg(a, b, c, d, x[i  9], 5 ,  568446438)
            d = gg(d, a, b, c, x[i 14], 9 , -1019803690)
            c = gg(c, d, a, b, x[i  3], 14, -187363961)
            b = gg(b, c, d, a, x[i  8], 20,  1163531501)
            a = gg(a, b, c, d, x[i 13], 5 , -1444681467)
            d = gg(d, a, b, c, x[i  2], 9 , -51403784)
            c = gg(c, d, a, b, x[i  7], 14,  1735328473)
            b = gg(b, c, d, a, x[i 12], 20, -1926607734)
            a = hh(a, b, c, d, x[i  5], 4 , -378558)
            d = hh(d, a, b, c, x[i  8], 11, -2022574463)
            c = hh(c, d, a, b, x[i 11], 16,  1839030562)
            b = hh(b, c, d, a, x[i 14], 23, -35309556)
            a = hh(a, b, c, d, x[i  1], 4 , -1530992060)
            d = hh(d, a, b, c, x[i  4], 11,  1272893353)
            c = hh(c, d, a, b, x[i  7], 16, -155497632)
            b = hh(b, c, d, a, x[i 10], 23, -1094730640)
            a = hh(a, b, c, d, x[i 13], 4 ,  681279174)
            d = hh(d, a, b, c, x[i  0], 11, -358537222)
            c = hh(c, d, a, b, x[i  3], 16, -722521979)
            b = hh(b, c, d, a, x[i  6], 23,  76029189)
            a = hh(a, b, c, d, x[i  9], 4 , -640364487)
            d = hh(d, a, b, c, x[i 12], 11, -421815835)
            c = hh(c, d, a, b, x[i 15], 16,  530742520)
            b = hh(b, c, d, a, x[i  2], 23, -995338651)
            a = ii(a, b, c, d, x[i  0], 6 , -198630844)
            d = ii(d, a, b, c, x[i  7], 10,  1126891415)
            c = ii(c, d, a, b, x[i 14], 15, -1416354905)
            b = ii(b, c, d, a, x[i  5], 21, -57434055)
            a = ii(a, b, c, d, x[i 12], 6 ,  1700485571)
            d = ii(d, a, b, c, x[i  3], 10, -1894986606)
            c = ii(c, d, a, b, x[i 10], 15, -1051523)
            b = ii(b, c, d, a, x[i  1], 21, -2054922799)
            a = ii(a, b, c, d, x[i  8], 6 ,  1873313359)
            d = ii(d, a, b, c, x[i 15], 10, -30611744)
            c = ii(c, d, a, b, x[i  6], 15, -1560198380)
            b = ii(b, c, d, a, x[i 13], 21,  1309151649)
            a = ii(a, b, c, d, x[i  4], 6 , -145523070)
            d = ii(d, a, b, c, x[i 11], 10, -1120210379)
            c = ii(c, d, a, b, x[i  2], 15,  718787259)
            b = ii(b, c, d, a, x[i  9], 21, -343485551)
            a = safe_add(a, olda)
            b = safe_add(b, oldb)
            c = safe_add(c, oldc)
            d = safe_add(d, oldd)
        }
        return [a, b, c, d]
    }
    function binl2hex(binarray)
    {
        var hex_tab = "0123456789abcdef"
        var str = ""
        for(var i = 0; i < binarray.length * 4; i )
        {
            str  = hex_tab.charAt((binarray[i>>2] >> ((i%4)*8 4)) & 0xF) 
            hex_tab.charAt((binarray[i>>2] >> ((i%4)*8)) & 0xF)
        }
        return str
    }
    function binl2b64(binarray)
    {
        var tab = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789 /"
        var str = ""
        for(var i = 0; i < binarray.length * 32; i  = 6)
        {
            str  = tab.charAt(((binarray[i>>5] << (i2)) & 0x3F) |
            ((binarray[i>>5 1] >> (32-i2)) & 0x3F))
        }
        return str
    }
    function str2binl(str)
    {
        var nblk = ((str.length   8) >> 6)   1 
        var blks = new Array(nblk * 16)
        for(var i = 0; i < nblk * 16; i ) blks[i] = 0
            for(var i = 0; i < str.length; i )
            blks[i>>2] |= (str.charCodeAt(i) & 0xFF) << ((i%4) * 8)
        blks[i>>2] |= 0x80 << ((i%4) * 8)
        blks[nblk*16-2] = str.length * 8
        return blks
    }
    function strw2binl(str)
    {
        var nblk = ((str.length   4) >> 5)   1
        var blks = new Array(nblk * 16)
        for(var i = 0; i < nblk * 16; i ) blks[i] = 0
            for(var i = 0; i < str.length; i )
            blks[i>>1] |= str.charCodeAt(i) << ((i%2) * 16)
        blks[i>>1] |= 0x80 << ((i%2) * 16)
        blks[nblk*16-2] = str.length * 16
        return blks
    }
    function hexMD5 (str) { return binl2hex(coreMD5( str2binl(str))) }
    function hexMD5w(str) { return binl2hex(coreMD5(strw2binl(str))) }
    function b64MD5 (str) { return binl2b64(coreMD5( str2binl(str))) }
    function b64MD5w(str) { return binl2b64(coreMD5(strw2binl(str))) }
    function calcMD5(str) { return binl2hex(coreMD5( str2binl(str))) }
}function String.MD5(str){return String.Convert(str).MD5();}

       for (var k in o) {  

/****************************************************************
    Misc
****************************************************************/
function GetTodayAtom()
{
    return Math.pow(1/2,(new Date("2000/1/1").getTime()-new Date().getTime())/1000/60/60/24/365)
}

           if (new RegExp("(" k ")").test(fmt)) fmt = fmt.replace(RegExp.$1, (RegExp.$1.length == 1) ? (o[k]) : (("00" o[k]).substr(("" o[k]).length)));  

3四、 写出函数Date德姆o的回到结果,系统时间假使为今日

function DateDemo(){

      var d, s="后天日期是:";

      d = new Date();              s = d.getMonth() 1 "/";

      s = d.getDate() "/";          s = d.getFullYear();

      return s;

}          结果:明日日子是:01/18/2018

       }  

       return fmt;  

35、  写出程序运维的结果?

   }  

for(i=0, j=0; i<10, j<6; i , j ){

      k = i j;      }                //结果:10

 

在那么些例子中有二个正则表达式的施用,RegExp.$一能够回来第3个非常的字符串,上面用一个事例来注脚难题。

3六、  阅读以下代码,请剖判出结果:

[javascript]  

var arr = new Array(1 ,3 ,5);                                                                          arr[4]='z';                                                                                                            arr2 = arr.reverse();                                                                                            arr3 = arr.concat(arr2);                                                                                    alert(arr3);                    //z,,5,3,1,z,,5,3,1

$(function () {  

       var r = /^(d{4})-(d{1,2})-(d{1,2})$/;  

37、写出大致描述html标签(不带属性的启幕标签和终止标签)的正则表明式,并将以下字符串中的html标签去除掉

var str = “<div>  这里是div  <p>里面包车型客车段落</p>  </div>;

<script type="text/javascript>”;

      var reg = /< /?w /?>/gi;

      var str = “<div>   这里是div < p>里面包车型大巴段落 </p>  </div>”;

      alert(str.replace(reg,”"));

</script>

        r.exec('1988-01-10');  

        s1 = RegExp.$1;  

3捌、  截取字符串abcdefg的efg

alert('abcdefg'.substring(4));   

        s2 = RegExp.$2;  

        s3 = RegExp.$3;  

3玖、  列举浏览器对象模型BOM里常用的足足6个对象,并列举window对象的常用方法至少两个

对象:window, document, location, screen, history, navigator

方法:alert(),  confirm(),  prompt(),  open(),  close()

        alert(s1 "," s2 "," s3)   

});  

40、  Javascript创设对象的三种艺术?

 

一、var obj = {};(使用json创建对象)                                                                如:obj.name = '张3';                                                                                      ​obj.action = function (){alert('吃饭');}​;                                                                贰、var obj = new Object();(使用Object创设对象)                                          如:obj.name = '张3';                                                                                      ​obj.action = function (){alert('吃饭');}​;                                                                三、​通过构造函数成立对象。                                                                        (1)、使用this关键字​如:                                                                              var obj = function (){                                                                                                    this.name ='张叁';                                                                                                this.age = 1九;                                                                                                      this.action = function (){                                                                                              alert('吃饭');                                                                                        }​;}                                                                                                                      ​(二)、使用prototype关键字如:                                                                            function obj (){                                                                                                  ​      obj.prototype.name ='张三';                                                                                ​obj.prototype.action=function (){                                                                              alert('吃饭');                                                                                            }}​;                                                                                                                        4、使用内置对象制造对象。                                                                        如:var str = new String("实例发轫化String");                                                          var str一 = "直接赋值的String";                                                                            var func = new Function("x","alert(x)");        //示例起头化func                            var obj = new Object();        //示例开端化3个Object

回到的结果:一9八七,0一,10

本文首即便对JavaSript的prototype属性使用体验进行总括,程序开采中太多时候大家习于旧贯了“.”那一个操作符,通过该操作符来引出对象放置的质量和格局,可是一些时候不要如我们希望的那么外人啥事都为大家准备好了,prototype属性让大家能在指标上自定义方法和性质。

...

41、事件绑定和普通事件有什么界别

平常增加事件的办法:

var btn = document.getElementById("hello");

btn.onclick = function(){    alert(1);  }

btn.onclick = function(){    alert(2);  }

实行上面的代码只会 alert 贰

事件绑定形式丰硕事件:

var btn = document.getElementById("hello");

btn.addEventListener("click",function(){    alert(1);  },false);

btn.addEventListener("click",function(){    alert(2);  },false);

实施上面的代码会先alert 壹 再alert 二

习认为常增多事件的艺术不援助增添八个事件,最上边包车型地铁风云会覆盖上边的,而事件绑定(add伊芙ntListener)方式丰盛事件可以加上三个。

add伊夫ntListener不包容低版本IE

平时事件不可能收回

add伊芙ntLisntener还协助事件冒泡 事件捕获           

本文由澳门新萄京官方网站发布于澳门新萄京赌场网址,转载请注明出处:常用运行库,JavaScript中判断对象类型的几种方法

关键词: