>

返回一个新数组(包含回调函数返回true的元素sb

- 编辑:澳门博发娱乐官网 -

返回一个新数组(包含回调函数返回true的元素sb

JavaScript 原生对象及扩展

2016/09/26 · JavaScript · 对象

原文出处: trigkit4   

最近在JavaSript进行Array操作的时候发现没有删除节点的方法,而我要实现的效果需要不断调用删除节点的方法,查找了相关资料发现可以利用prototype属性给Array增加删除节点的方法,并且该方法同Array自身拥有的push()、pop()、reverse()、slice()、sort()、join()等方法一样使用。

1、 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是一个只有一个值的数据类型,这个值就是null。表示一个空指针对象,所以用typeof检测会返回 ”object ”

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

我们知道,JavaScript中检测对象类型的运算符有:typeof、instanceof,还有对象的constructor属性:

内置对象与原生对象

内置(Build-in)对象与原生(Naitve)对象的区别在于:前者总是在引擎初始化阶段就被创建好的对象,是后者的一个子集;而后者包括了一些在运行过程中动态创建的对象。

sbf282.com 1

 

function LostinetJScriptRuntimeLibrary(){}

1) typeof 运算符 typeof 是一元运算符,返回结果是一个说明运算数类型的字符串。如:"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、URIError、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种强制类型转换和2种隐式类型转换?

强制(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实现提供的对象,独立于宿主环境,在一个脚本程序执行的开始处。

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

来源:

举个栗子:

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][2 只定义了两个新的内置对象,即 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)

sbf282.com 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
****************************************************************/

所以它只在区别对象和原始类型的时候才有用。要区一种对象类型和另一种对象类型,必须使用其他的方法。如:instanceof 运算符或对象的 constructor 属。

用原型扩展对象

对js原生对象的扩展无非就是往prototype里注册,例如,我们可以往String对象里扩展ltrim,rtrim等方法。js每个对象都继承自Object,并且,对象和其他属性都通过prototype对象来继承。通过prototype对象,我们可以扩展任何对象,包括内建的对象,如StringDate

Array.prototype.remove = function (dx) {  

4、数组方法 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 运算符要求其左边的运算数是一个对象,右边的运算数是对象类的名字或构造函数。如果 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.执行顺序不一样、

2.参数不一样

3.事件加不加on

4.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 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 }

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,arg2...)  //将所有参数一个一个传递进去

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)%62;
        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中对象的创建有以下几种方式:

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

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

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

        }  

9、 添加 删除 替换 插入到某个元素的方法

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字符串,两边的引号已经加了""
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属性。 2)连接字符串:"[object "+结果(1)+"]" 3)返回 结果(2) 例如:

本文由胜博发-前端发布,转载请注明来源:返回一个新数组(包含回调函数返回true的元素sb