潜说js对象和数组,原生对象及伸张

JavaScript 原生对象及增加

2016/09/26 · JavaScript
· 对象

初稿出处: trigkit4   

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 ”

js API
1.全局对象
NAN 非数字值的很是值
infinity 代表正无穷的数据
undefined

复制代码 代码如下:

停放对象与原生对象

内置(Build-in)对象与原生(Naitve)对象的分别在于:前者总是在发动机伊始化阶段就被成立好的靶子,是后世的一个子集;而后人包蕴了一部分在运转进程中动态创建的目的。

亚洲必赢官网 1

2.函数属性
eval() 可总括某个字符串,并重临字符串的值
parseInt() 取整
parseFloat() 取浮点数
isNAN() 检查参数是不是是非数字
isFinite() 检查参数是不是为无穷大

/*
数组和目的 【JavaScript 权威指南 第五版】
*/

原生对象(New后的目的)

ECMA-262 把原生对象(native object)定义为“独立于宿主环境的
ECMAScript 完毕提供的对象”。包含如下:

Object、Function、Array、String、Boolean、Number、Date、RegExp、Error、伊娃(Eva)lError、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 定义的类(引用类型)。

来源:

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

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

隐式(== ,!!)

3.处理URI的函数属性
decodeURI() 可对encodeURI()函数编码过来的URI进行剖析
decodeURIComponent() 函数可对 encodeURIComponent() 函数编码的 URI
举办解码。
encodeURI 函数可把字符串作为 URI 进行编码
encodeURIComponent 函数可把字符串作为 URI 组件举办编码。

/*
目的: 是一个无序属性集合, 每个属性都有协调的名字和值 */

置于对象(不须要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,
set提姆(Tim)eout, 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)

亚洲必赢官网 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;

潜说js对象和数组,原生对象及伸张。输出: 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>

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

前端是切割成数组的样式,后者是将数组转换成字符串

4.构造器属性
Object 原型对象
Function 函数
Array 数组
String
Boolean
Number
Date
RegExp 正则 包涵七个点子(text(),exec(),compile())
Error
EvalError
RangeError
ReferenceError
SyntaxError
TypeError
URIError

/* 成立对象简单方法, 对象直接量 */
var obj = {};
var obj = {name: ‘maxthon’};
var obj = {name: {}, text: []};

用原型扩大对象

对js原生对象的扩充无非就是往prototype里登记,例如,大家可以往String目的里扩张ltrim,rtrim等办法。js每个对象都一而再自Object,并且,对象和此外性能都因此prototype目的来一而再。通过prototype目的,大家可以扩张任何对象,包含内建的靶子,如StringDate

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

push() 尾部添加      pop() 底部剔除

unshift() 底部添加  shift() 尾部删除

map() : 遍历数组中的元素, 重临一个新数组(包罗回调函数重返的数量)

filter():遍历数组中的元素, 再次来到一个新数组(包罗回调函数重回true的要素)

5.全局目的其余性能
Math 数学方法
Jason

/* 可使用 new 操作符 */
var a = new Array();
var d = new Date();
var r = new RegExp(‘javascript’, ‘i’);
var o = new Object(); // var o = {};
/* 注: new 操作符后跟构造函数, 所以
typeof Array; // ‘function’
typeof Object; // ‘function’
Object 是 Function 的实例.
Function 是特种的目标, 也是 Object 的实例.
*/

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(/\r\n/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(/\r\n/g, ‘<br />’);
                s = s.replace(/\r/g, ‘<br />’);
                s = s.replace(/\n/g, ‘<br />’);
            }
            return s;
        }
    }
</script>

5、IE和DOM事件流的分裂

1.执行种种差异、

2.参数不等同

3.风云加不加on

4.this指向问题

6.Object对象
布局器属性
Object.prototype 代表对象Object的原型对象
Object.getPrototype() 重返一个obj的原型
Object.getOwnPropertyDescriptor(object, propertyname)
得到指定对象自我性质描述符
Object.getOwnPropertyNames() 获得所有的属性名,以一个数组的款型再次来到
Object.create(proto,[propertiesObject])
创设一个享有指定原型或若干原型指定原型的靶子
Object.defineProperty(object, propertyname, descriptor) 1:对象
2必要定义的性质或格局的名字 3:目的属性所持有的特点
Object.defineProperties(object, descriptors)
将一个性能或多个属性添加到对象,或改动现有属性
Object.seal(obj)阻止修改现有属性的特点,并阻止添加新属性
Object.freeze(obj)阻止修改现有属性的风味和值,并堵住添加新属性
Object.preventExtensions(obj)阻止向目标添加新属性
Object.isSealed(obj)
借使无法在目的中修改现有属性的特色,且无法向目标添加新属性,则赶回true
Object.isFrozen(obj)
假设无法在对象中修改现有属性的特点和值,且不能向目标添加新属性,则赶回true
Object.isExtensible() 重返一个值,该值提醒是或不是可向对象添加属性
Object.is(val1,val2) 再次来到一个值,该值提示八个值时候同样
Object.keys(obj) 范湖目的可枚举属性和方法的名称
原型对象属性
proto指向该实例对象对应的原型对象 function foo(){}; var f1=new foo;
console.log(f1.proyo===foo.prototype);//ture
Object.prototype 指向实力对象的原型对象
Object.prototype.constructor 再次回到对创造对象实例的Obj构造函数
Object.prototype.toString() 方法再次来到一个象征该目的的字符串
Object.prototype.toLocalString()
重临一个意味着该目的的字符串.该方法首假如被本地化相关对象覆盖
Object.protopyte.valueOf() 重返指定的原始值 好难知晓
Object.prototype.hasOwnProperty(prop) 用来判定某个对象是或不是含有指定属性
Object.prototype.isPrototypeOf(obj)
用来测试一个对象是否留存别的一个指标的原型链上
Object.prototype.propertyIsEnumberable(prop)
重临一个布尔值,表示属性是不是是当前性能可枚举的布尔值

/* 对象属性 */
// 使用 . 符合来存取属性的值.
// 注:同时可利用 [], 里面使用属性名(可拔取变量, 那点更加实用).
var t = {};
t.text = ‘hello’;
t.o = {};
t.o.name = ‘rd’;
t.n = [];

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);
 
                    }
 
                });
 
            };
        }

6、IE和标准下有哪些包容性的写法

var ev = ev || window.event

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

var target = ev.srcElement||ev.target

7Function对象
协会器属性
Function.prototype 储存function的原型对象
Function.length 形参的个数
原型对象属性
Function.prototype.constructor
Function.prototype.toString() 再次回到一个表当前函数的字符串
Function.prototype.apply()
Function.prototype.call()
Function.prototype.bind()
方法会创立一个新的函数,第二个参数会作为运行时的this,之后的参数会在从传递的实参前传出作为他的参数

var t = {
“text”: “hello”
};
console.log(t.text); // ‘hello’;
// 补充: 寻常使用首要字 var 来声称变量, 不过宣称对象属性时, 无法利用
var 申明

选取原生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 }

7、call和apply的区别

意义雷同, 都是将眼前函数作为指定对象的不二法门执行,
即函数中的this是指定对象

call(thisObj,arg1,arg2…)  //将所有参数一个一个传递进入

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

8Array对象
协会器属性
Array.prototype
Array.isArray
原型对象属性
Array.prototype.constructor
Array.prototype.toString()
Array.prototype.toLocalString()
Array.prototype.concat() 合并数组
Array.prototype.join(spear)
将数组中的元素以一个字符串的款式导出,spear可为分隔符
Array.prototype.pop() 删除数组的末梢一个因素
Array.prototype.push() 添加一个或一组元素,并重临新的数组
Array.prototype.reverse() 颠尾数组中的元素 首个会化为终极一个
Array.prototype.shift() 删除数组中的第二个元素
Array.prototype.slice(begin,end) 浅拷贝数组里的要素,包蕴右侧不分包左边
Array.prototype.sort(compareFunction)
默许元素做原地排序,compareFunction可以指定魔种排序格局
Array.prototype.splice(start,deleteCount,item1)
用新因素交替就元素,以次修改数组的内容.
start起头的index,delecount持续的个数,item1替换的情节,若为空,则意味着删除
array.splice(2,0,’cat’) 把数组index=2替换为cat
Array.prototype.unshift() 在初叶添加一个或四个因素
Array.prototype.indexOf() 重返元素的索引值,不设有为-1
Array.prototype.lastIndexOf() 再次回到元素在数组中的最终一个索引值
Array.prototype.every() 方法测试元素是不是经过点名函数的测试
function isBigEnough(element, index, array) { return (element >=
10);}
var passed = [12, 5, 8, 130, 44].every(isBigEnough);// passed is
false
passed = [12, 54, 18, 130, 44].every(isBigEnough);// passed is true
Array.prototype.some() 测试数组中是不是有元素通过了指定函数的检测
Array.prototype.forEach() 数组中每个元素提供一个指定的函数
Array.prototype.map() 元素组中每一个因素调用一个方法后重临一个新的数组
Array.prototype.filter()用指定的函数测试所有因素,并成立一个暗含所有通过元素的数组
Array.prototype.fill(value,start,end) 将数组摸一个区域的要素交替为value
[1, 2, 3].fill(4, 1, 2) // [1, 4, 3]
Array.prototype.reduce()
函数作为一个累加器,把数组中的每个元素(自左至右)累加成一个数组
var flattened =[[0,1],[2,3],[4,5]].reduce(function(a,b){return
a.concat(b),[]});
//flattened[0,1,2,3,4,5]
Array.prototype.reduceRight()

/* 对象枚举 */

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

详情:

8、怎么堵住事件冒泡和事件默许行为

//阻止事件冒泡

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

              ev.stopPropagation();

} else { //非标准IE

              window.event.cancelBubble = true;

}

//阻止事件默许行为

return  false

9.String对象
String.prototype
String.fromCharCode() 可接受一个unicode值,然后回来一个字符串
document.write(72,69,76,76,79) //hello
prototype属性
String.prototype.constructor
String.prototype.toString() 将一个逻辑值转化为字符串,并赶回结果 var
boo=new boolean(true) document.write(boo.toString())//true
String.prototype.valueOf() 方法重回string的原始值
String.prototype.charAt() 重返字符串中指定地点的字符
String.prototype.charCodeAt() 重返字符串的unicode值
String.prototype.concat() 将一个或多少个字符串连接起来
String.prototype.indexOf(searchValue,fromindex)
指定的值在字符串中首次出现的地点.从formindex开端
String.prototype.lastIndexOf(searchValue,fromindex)指定值在字符串最终一遍面世的地方.从from
index早先
String.prototype.localeCompare() 对比字符串的岗位
String.prototype.match(regexp)
当字符串匹配正则表明式(regexp)时,match会调用其艺术
String.prototype.replace() 用一个新的字符串替换原字符串中的部分字符串
String.prototype.search(regex)
执行一个物色,看字符串对象与一个正则表达式是或不是顺应
String.prototype.slice(begin,end) 前拷贝字符串
String.prototype.split() 把字符串分割成一个子字符串的数组 “Webkit Moz O
ms Khtml”.split( ” ” ) // [“Webkit”, “Moz”, “O”, “ms”, “Khtml”]
String.prototype.substring(startindex,endindex)
重临字符串四个目录之间的子串
String.prototype.toLowerCase() 将字符串转化为小写,并赶回
String.prototype.toLocalLowerCase()
字符串转化为小写。会按照本地化大小映射
String.prototype.toUpperCase() 转化为题写
String.prototype.toLocaleUpperCase()
String.prototype.trim() 删除字符串两端的空白符

var F = function () {};
F.prototype.name = ‘RD’;
var obj = new F;
for (var key in obj) {
console.log(key); // name;
}

对象的创造

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)自定义对象构造

10 Boolean对象
结构器属性
prototype
原型对象的属性
Boolean.prototype.constructor
Boolean.prototype.toString() 布尔目的以字符串方式再次来到
Boolean.prototype.valueOf() 再次回到原始值

// 仅枚举对象自我, 不沿原型链向上查
for (var key in obj) {
if (obj.hasOwnProperty(key)) {
console.log(key); //
}
}
/* 注: for in 不可以枚举出预订义属性; toString. */

一、使用内置对象

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()

11Number对象
结构器属性
prototype
MAX_VALUE
MIN_VALUE
NaN
NEGATIVE_INFINITY 负无穷
POSITIVE_INFINITY 正无穷
原型对象的属性
Number.prototype.constructor
Number.prototype.toString()
Number.prototype.toLocaleString()
Number.prototype.valueOf() 重临num的原始值
eg:var numObj = new Number(10);
console.log(typeof numObj); // object
var num = numObj.valueOf();
console.log(num); //
Number.prototype.toFixed() 使用一定表示法来格式化一个数
eg: var numObj = 12345.6789;
numObj.toFixed(); // 再次来到 “12346”:进行四舍五入,不包蕴小数部分
numObj.toFixed(1); // 重临 “12345.7”:进行四舍五入
Number.prototype.toExponential() 以指数表示法再次回到该数值字符串表现方式
eg: var numObj = 77.1234;
numObj.toExponential(4)); //输出 7.7123e+1
Number.prototype.toPrecision() 以指定精度重返该数据的字符串方式

/* 检查属性存在性 */

停放对象列表

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

上述资料来自:

10、javascript的内置对象和宿主对象

嵌入对象为Object, Array, Function, Date, Math等

宿主为浏览器自带的window 等

12 Math对象
值属性
E
LN10
LN2
LOG2E
LOG10E
PI
SQRT1_2
SQRT2 2的平方根
函数属性:
abs() 绝对值
acos()反cos
asin()
atan()
atan2() 反正切函数
ceil(x)重临一个压倒或等于x的最小值
cos()
exp(x)函数重返 ex,x 代表参数
floor(x)再次回到一个稍低于或等于x的最大值
log()
max()
min()
pow(base, exponent) 函数再次回到基数(base)的指数(exponent)次幂
random()
round()重临一个四舍五入最接近的值
sin()
sqrt()函数重返一个平方根
tan()

window.a = ‘rd’;
console.log(a in window); // true;

自定义对象社团

创建高级对象社团有两种艺术:使用“this”关键字构造、使用原型prototype构造

11、window.onload和document ready的区别

window.onload 是在dom文档树加载完和所有文件加载完事后执行一个函数

document.ready原生中从不那一个办法,jquery中有
$().ready(function),在dom文档树加载完之后执行一个函数(注意,这中间的文档树加载完不意味整个文本加载完)。

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

window.onload只好出去一次,$(document).ready可以出现多次

13Date对象
协会器属性
Date.prototype
Date.parse() 解析一个日子字符串,并赶回为从1970到字符串的光阴
Date.parse(“Wed, 09 Aug 1995 00:00:00 GMT”);
Date.UTC() 重临从1970到指定日期的飞秒数 Date.UTC(96, 11, 1, 0, 0, 0)
Date.now() 重返1970到近年来时间的微秒数
原型对象属性
Date.prototype.constructor
Date.prototype.toString()
Date.prototype.toDateString()
Date.prototype.to提姆eString() 大致 格式不太相同
Date.prototype.toLocaleString()
Date.prototype.toLocaleDateString()
Date.prototype.toLocaleTimeString()
Date.prototype.valueOf() 重返对象的原始值
Date.prototype.get提姆(Tim)e() 重回一个时刻的格林(格林)尼治时间
eg: var birthday = new Date(1994, 12, 10);
birthday.getTime()
Date.prototype.getFullYear()
Date.prototype.getUTCFullYear()
Date.prototype.getMonth()
Date.prototype.getUTCMonth()
Date.prototype.getDate()
Date.prototype.getUTCDate()
Date.prototype.getDay()
Date.prototype.getUTCDay()
Date.prototype.getHours()
Date.prototype.getUTCHours()
Date.prototype.getMinutes()
Date.prototype.getUTCMinutes()
Date.prototype.getSeconds()
Date.prototype.getUTCSeconds()
Date.prototype.get米尔iseconds()
依照地点时间,重返一个置顶日期对象的阿秒值
Date.prototype.getUTCMilliseconds()
Date.prototype.getTimezoneOffset()
Date.prototype.setTime()
Date.prototype.setFullYear()
Date.prototype.setUTCFullYear()
Date.prototype.setMonth()
Date.prototype.setUTCMonth()
Date.prototype.setDate()
Date.prototype.setUTCDate()
Date.prototype.setHours()
Date.prototype.setUTCHours()
Date.prototype.setMinutes()
Date.prototype.setUTCMinutes()
Date.prototype.setSeconds()
Date.prototype.setUTCSeconds()
Date.prototype.setMilliseconds()
Date.prototype.setUTCMilliseconds()
Date.prototype.toUTCString()
Date.prototype.toISOString()方法再次回到一个iso格式的日子
YYYY-MM-DDTHH:mm:ss.sssZ时区总是etc,后缀加一个z
Date.prototype.toJSON() 重返一个son格式的字符串

var F = function () {};
F.prototype.name = ‘RD’;
var obj = new F;
console.log(‘name’ in obj); // true;

Date对象

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

前端会自动转换类型

后来人不会

14RegExp对象
布局器属性
RegEx.prototype
原型对象属性
RegExp.prototype.exec()
为指定的一段字符串进行搜索匹配,再次回到一个数组活着null
RegExp.prototype.test()
执行一个找寻,用来查看正则表明式与指定字符串是还是不是匹配
RegExp.prototype.toString() 重返一个意味着该正则表达式的字符串
eg: foo = new RegExp(“bar”, “g”);
alert(foo.toString()); // 显示 “/bar/g”
实例属性:
source 当前正则表明式形式文本的字符串
global 是还是不是同盟所有的选项,是一个只读属性,使用g标识
ignoreCase 表示忽略大小写,只读属性,使用i标识
multiline 表示多行字符串被看做多行,只读属性,使用m标识
lastIndex

var toString = Object.prototype.toString;

get系列措施

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)。 get米尔iseconds() 重临 Date
对象的阿秒(0 ~ 999)。 get提姆e() 重回 1970 年 1 月 1 日至今的阿秒数。
get提姆(Tim)ezoneOffset() 再次来到本地时间与格林威治标准时间 (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)。
getUTC米尔(Mill)iseconds() 根据世界时再次回到 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是一门怎么的语言,它有啥特征?

javaScript一种直译式脚本语言,是一种动态类型、弱类型、基于原型的言语,内置帮忙项目。它的解释器被称为JavaScript引擎,为浏览器的一局地,广泛用于客户端的脚本语言,最早是在HTML网页上接纳,用来给HTML网页扩展动态效率。JavaScript兼容于ECMA标准,由此也号称ECMAScript。

主导特色

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

2.
要害用以向HTML(标准通用标记语言下的一个用到)页面添加交互行为。

3.
方可一贯嵌入HTML页面,但写成独立的js文本有利于结构和行事的分离。

跨平台特色,在多数浏览器的支撑下,可以在多种平台下运作(如Windows、Linux、Mac、Android、iOS等)

// 借使目的 obj, 含有方法 getName, 则执行它;
if (obj.getName && toString.call(obj.getName) === ‘[object Function]’)
) {
obj.getName();
}

set体系措施

setDate() 设置 Date 对象中月的某一天 (1 ~ 31)。 setMonth() 设置 Date
对象中月份 (0 ~ 11)。 setFullYear() 设置 Date
对象中的年份(四位数字)。注意不要使用setYear()方法。 setHours() 设置
Date 对象中的刻钟 (0 ~ 23)。 setMinutes() 设置 Date 对象中的分钟 (0 ~
59)。 setSeconds() 设置 Date 对象中的分钟 (0 ~ 59)。 set米尔(Mill)iseconds()
设置 Date 对象中的微秒 (0 ~ 999)。 set提姆e() 以飞秒设置 Date 对象。
setUTCDate() 根据世界时设置 Date 对象中月份的一天 (1 ~ 31)。
setUTCMonth() 根据世界时设置 Date 对象中的月份 (0 ~ 11)。
setUTCFullYear() 依据世界时设置 Date 对象中的年份(四位数字)。
setUTCHours() 根据世界时设置 Date 对象中的时辰 (0 ~ 23)。
setUTCMinutes() 根据世界时设置 Date 对象中的分钟 (0 ~ 59)。
setUTCSeconds() 依照世界时设置 Date 对象中的分钟 (0 ~ 59)。
setUTC米尔iseconds() 按照世界时设置 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)。

13、JavaScript的数据类型都有怎么着?

着力数据类型:String,boolean,Number,Undefined, Null

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

那么问题来了,如何判定某变量是否为数组数据类型?

办法一.论断其是或不是拥有“数组性质”,如slice()方法。可自己给该变量定义slice方法,故有时会失效

格局二.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]”

        };

};

// 补充:
console.log(null == undefined); // true;
console.log(null !== undefined); // true;

toString系列措施

toString() 把 Date
对象转换为字符串,toString()总是回到一个用美式拉脱维亚语表明的字符串。
to提姆eString() 把 Date 对象的岁月有些更换为字符串。 toDateString() 把
Date 对象的日期部分更换为字符串。 toUTCString() 根据世界时,把 Date
对象转换为字符串。 toLocaleString() 根据地方时间格式,把 Date
对象转换为字符串。 toLocale提姆(Tim)eString() 依照地面时间格式,把 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 对象的日期部分转换为字符串。

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相等,但不恒等(===)                                 
                                             
一个是number一个是string时,会尝试将string转换为number尝试将boolean转换为number,0或1品尝将Object转换成number或string,取决于别的一个对计量的系列所以,对于0、空字符串的判定,指出使用
“===” 。“===”会先判断两边的值类型,类型不匹配时为false。

那么问题来了,看下边的代码,输出什么,foo的值怎么?

var foo = “11”+2-“1”;                                                 
                                      console.log(foo);               
                                                                     
                      console.log(typeof
foo);执行完后foo的值为111,foo的序列为String。

/* 删除属性 */
delete obj.name;
// 补充: 使用 delete 操作符, 不可能去除使用 var 评释的变量;

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
    允许为所有对象附加属性.

15、已知有字符串foo=”get-element-by-id”,写一个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;

}

// 取对象属性:
obj.name;
obj[‘name’]; // 那里 name 为字符串.

方法

这一个方式能够改变数组自身:

pop 移除数组的最终一个因素,再次来到值是被剔除的因素。 push
在数组的终极添加一个照旧五个要素,重回值是新的数组的长短。 reverse
颠尾数组中元素的逐条,原先第三个因素现在成为最终一个,同样原先的末梢一个要素变为了当今的率先个,也就是数组的目录发生了变更。
shift 删除数组的首先个因素,重临值是删除的要素。 sort
对数组中的元素举行排序。 splice 添加或删除数组中的一个或三个元素。
unshift 添加一个或者七个因素在数组的上马,再次来到值是新的数组的尺寸。

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
    添加一个或者多个元素在数组的开头,返回值是新的数组的长度。

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  })

// 使用 [] 表示时, 属性名是用字符串来代表的. 那么可
// 在运行进程中开展添加等操作
// 注:当此属性是做为变量传递时, 尤其有用.
// 又称 关联数组

Accessor 方法

那些经过不改动数组自身

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.

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.

17、输出今日的日期,以YYYY-MM-DD的法子,比如前几日是二零一四年3月26日,则输出2014-09-26

var d = new Date();

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

var month = d.getMonth() + 1;  //
获取月,月份相比特殊,0是二月,11是13月

month = month < 10 ? ‘0’ + month : month;    // 变成两位

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

day = day < 10 ? ‘0’ + day : day;

alert(year + ‘-‘ + month +’-‘ + day);

/* 映射: JavaScript 对象把字符串(属性名) 映射成值. */
for (var key in obj) {
console.log(key); // key 属性名, 此处 做为值存在.
}

循环(迭代)过程

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。

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。

/*
通用的 Object 属性和方法

总结:

变更原数组的法子: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}替换成10,{$name}替换成托尼(Tony) (使用正则表明式)

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

JavaScript 中具备目的都持续自 Object 类;

Boolean

19、为了有限支撑页面输出安全,我们平常要求对有的异样的字符举行转义,请写一个函数escapeHtml,将<, >, &, “进行转义

function escapeHtml(str) {

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

      switch (match) {

                  case “<”:

                      return “<”;

                  case “>”:

                      return “ >”;

                  case “&”:

                      return “&”;

                  case “\””:

                      return “””;

      }  });}

1, constructor 属性.
指向其社团函数.
*/
var F = function () {};
var f = new F;
console.log(f.constructor == F); // true

属性

JavaScript

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

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

// 构造函数的原型存在属性 constructor 指向和睦;
F.prototype.constructor == F;

方法

JavaScript

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

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

19、foo = foo||bar ,这行代码是什么意思?为啥要那样写?

假使foo存在,值不变,否则把bar的值赋给foo。

卡住表明式:作为”&&”和”||”操作符的操作数表达式,这几个表明式在开展求值时,只要最终的结果早就足以确定是真或假,求值进程便告终止,那称之为短路求值。

mic6f$�Y

// 补充:
var F = function () {};
var G = function () {};
G.prototype = new F;

String 对象

20、看下列代码,将会输出什么?(变量讲明进步)

var foo = 1;

(function(){

    console.log(foo);

    var foo = 2;

    console.log(foo);

})()

答案:输出undefined 和 2。上边代码相当于:

var foo = 1;

(function(){

    var foo;

    console.log(foo); //undefined

    foo = 2;

    console.log(foo); // 2; 

})()

函数讲明与变量表明会被JavaScript引擎隐式地升级到当下功效域的顶部,可是只进步名称不会提高赋值部分

var g = new G;
console.log(g.constructor == F); // true;
console.log(g.constructor == G); // false;
// 可使用 g instanceof F;

属性

JavaScript

String.length String.prototype

1
2
String.length
String.prototype

/*
2, toString() 方法
*/
{‘name’: ‘maxthon’}.toString(); // ‘[object Object]’

方法:

JavaScript

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()
方法用于把字符串转换为大写。

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–100里头的10个数字,存入一个数组,并排序。

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

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

                  return ‘超过’ + min + ‘-‘ + max + ‘之间的个数范围’ +
(max – min – 1) + ‘个的总和’;

              }

              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);

/* 数组使用 toString 方法, 把会元素结合字符串, 其余对象会转接为
[object Object];
函数使用原始 toString 方法, 会得到函数源码 */
[‘a’, ‘b’, 1, false, [‘e’,’f’], {}].toString();
// “a,b,1,false,e,f,[object Object]”

RegExp对象

21、 把八个数组合并,并剔除第四个要素。

var array1 = [‘a’,’b’,’c’];

var bArray = [‘d’,’e’,’f’];

var cArray = array1.concat(bArray);

cArray.splice(1,1);

function t() {
console.log(‘test’);
}
t.toString();
// 源码

属性

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
正则对象的源模式文本。

/*
3, toLocalString();
回来对象的一个地方化字符串
4, valueOf();
在倒车为主干类型时, 会使用到. valueOf/toString.
5, hasOwnProperty();
6, propertyIsEnumberable();
是或不是可枚举出来;
7, isPrototyeOf();
a.isPrototyeOf(b);
如果 a 是 b 的原型, 则返回 true;
*/
var o = {}; // new Object;
Object.prototype.isPrototyeOf(o); // true;
Object.isPrototyeOf(o); // false;
o.isPrototyeOf(Object.prototype); // false;
Function.prototype.isPrototyeOf(Object); // true;

方法

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() 方法。

22、  怎么样添加、移除、移动、复制、创立和查找节点(原生JS,实在基础,没细写每一步)

1)创设新节点

createDocumentFragment()    //创制一个DOM片段

createElement()  //创建一个切实的因素

createTextNode()  //创造一个文本节点

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

appendChild()      //添加

removeChild()      //移除

replaceChild()      //替换

insertBefore()      //插入

3)查找

getElementsByTagName()    //通过标签名称

getElementsByName()    //

通过元素的Name属性的值

getElementById()        //

透过元素Id,唯一性没细

/* 【闭包是存在函数实例, 垃圾没有回收是存在赋值引用】 */

Object对象

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

23、  有那样一个URL:, 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;

}

/*
数组: 有序的、值的联谊;

性能或方法

Object的各种实例都有所共同的着力性能和方式

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

24 、 正则表明式构造函数var reg=new RegExp(“xxx”)与正则表明字面量var reg=//有啥分化?匹配邮箱的正则表明式?

当使用RegExp()构造函数的时候,不仅必要转义引号(即\”表示”),并且还亟需双反斜杠(即\\表示一个\)。使用正则表达字面量的功效更高。

邮箱的正则匹配:

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

各类值, 也叫元素, 对应一个下标;
下标是从 0 伊始;
数组中值, 可以为其余类型. 数组, 对象, null, undefined.
*/

静态方法

JavaScript

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) 重回指定对象的原型

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)
返回指定对象的原型

25、 看上边代码,给出输出结果。

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

      setTimeout(function(){

              console.log(i);

        },0);

};    答案:4 4 4。

案由:回调函数是在for停止未来才运行的。 怎么样让上述代码输出1 2 3?

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

      set提姆(Tim)eout((function(j){  //改成当下施行函数

                console.log(j);

      })(i),0);

};

// 创建.
var arr = [];
var arr = new Array();

大局属性和方式

var t = ”;
var arr = [1,2,3, null, undefined, [], {}, t];

全局方法

亚洲必赢官网 3

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

if (!String.prototype.trim) {

      String.prototype.trim = function() {

              return this.replace(/^\s+/, “”).replace(/\s+$/,””);

        }

}

//测试    var str = ” \t\n test string “.trim();

            alert(str== “test string”); // alerts “true”

/* 使用 new 操作符创设数组的3种景况: */
var arr = new Array(); // [], 和直接量相同

全局属性

亚洲必赢官网 4

1 赞 3 收藏
评论

亚洲必赢官网 5

27、 1.    Javascript中, 以下哪条语句一定会发出运行错误?     

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

var arr = new Array(5); // 长度为 5; []直接量是无力回天做到的.
console.log(arr); // []; JavaScript 引擎会一笑置之 undefined;

var arr = new Array(‘5’); // 值为 [‘5’];
var arr = new Array(‘test’); // 值为 [‘test’];

28、  以下四个变量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’ 

/* 相关实例 */
var s = [1, 2, 3];
s[5] = ‘a’;
console.log(s);
[1, 2, 3, undefined, undefined, ‘a’]

/* 数组的读和写 */

29、var a=10; b=20; c=4;  ++b+c+a++ 以下哪些结果是不易的?

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

value = array[0];
a[1] = 3.14;
i = 2;
a[i] = 3;
a[a[i]] = a[0];

// 数组 -> 对象 -> 属性
array.test = ‘rd’;

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=””;

      }

}

// 数组下标大于等于 0, 并且小于 2的32次方 减 1 的整数.
// 别的值, JavaScript 会转化成字符串, 做为对象属性的名字, 不再是下标.

31、  要将页面的意况栏中突显“已经入选该文本框”,下列JavaScript语句正确的是( A )

var array = [];
array[9] = 10; // array 长度会变成 10;
// 注: JavaScript 解释器只给数组下标为 9 的元素分配内存, 其余下标无.

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

var array = [];
array.length = 10; // 添加 array 的长度;
array[array.length] = 4;

/* 删除数组元素 */
// delete 运算符把一个数组元素设置为 undefined 值,
不过因素本身照旧存在的.
// 真正删除, 可以应用: Array.shift();【删除第三个】
Array.pop();【删除最终一个】
Array.splice();【从一个数组中去除一个连续范围】 或改正 Array.length
长度;

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

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

/* 相关实例 */
var a = [1, 2, 3];
delete a[1];
console.log(a); // [1, undefined, 3];

/* 补充: JavaScript 权威指南 第五版 59页
由 var 注解的变量是永久性的, 也就是说, 用 delete
运算符来删除这一个变量将会掀起错误.
但: 在开发者工具里面, 是可以去除的. 而在网页中, 正如书上所写.
*/

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

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

  • (c++) + a++;                                                       
                  alert(e);弹出提醒对话框:77

/* 数总监度 */
[].length;

/* 遍历数组 */
var array = [1, 2, 3, 4, 5];
for (var i = 0, l = array.length; i < l; i++) {
console.log(array[i]);
}

34、 写出函数DateDemo的归来结果,系统时间即便为今日

function DateDemo(){

      var d, s=”前些天日子是:”;

      d = new Date();              s += d.getMonth() +1+ “/”;

      s += d.getDate() + “/”;          s += d.getFullYear();

      return s;

}          结果:前几日日子是:01/18/2018

array.forEach(function (item, index, arr) {
console.log(item);
});

/* 截取或加强数组: 校正 length 长度, 前边已提过 */

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

/* 多维数组 */
[[1], [2]]

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

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

/* 数组方法 */
// join
var array = [1, 2, 3, 4, 5];
var str = array.join(); // 1,2,3,4,5
var str = array.join(‘-‘); // 1-2-3-4-5
// 注: 此方法与 String.split() 方法相反;

// reverse();
var array = [1, 2, 3, 4, 5];
array.reverse(); // [5, 4, 3, 2, 1]
// 注:修改原数组;

36、  阅读以下代码,请分析出结果:

// sort();
var array = [1, 3, 2, 4, 5, 3];
array.sort();// [1, 2, 3, 3, 4, 5];
/* 注: 数组中留存未定义元素, 把那个要素放到最终 */

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

/* 同时可自定义排序, sort(func);
func 接收三个参数, 若是第二个参数应该放在第一个参数从前,
那么相比较函数将再次来到一个小于0的数, 相反, 再次来到大于0的数. 相等, 再次回到0;
*/
array.sort(function (a, b) {
return b – a;
});

// 实例: 按奇数到偶数, 并且从小到大排序
[1, 2, 3, 4, 5, 6, 7, 2, 4, 5, 1].sort(function (a, b) {
if (a % 2 && b % 2) {
return a – b;
}

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>

if (a % 2) {
return -1;
}

if (b % 2) {
return 1;
}

38、  截取字符串abcdefg的efg

alert(‘abcdefg’.substring(4));   

return a – b;

});

39、  列举浏览器对象模型BOM里常用的足足4个目标,并列举window对象的常用方法至少5个

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

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

// concat() 方法. 合并数组, 但不深度合并
var a = [1, 2, 3];
a.concat(4, 5); // [1, 2, 3, 4, 5]
a.concat([4, 5]); // [1, 2, 3, 4, 5]
a.concat([4, 5], [8, 9]); // [1, 2, 3, 4, 5, 8, 9]
a.concat([4, 5], [6, [10, 19]]); // [1, 2, 3, 4, 5, 6, [10, 19]
]

// slice() 方法. 源数组不改变.
var a = [1, 2, 3, 4, 5];
a.slice(0, 3); // [1, 2, 3]
a.slice(3); // [4, 5];
a.slice(1, -1); // [2, 3, 4]
a.slice(1, -1 + 5)
a.slice(1, 4);
a.slice(-3, -2); // [3]
a.slice(-3 + 5, -2 + 5);
a.slice(2, 3);
/* 注:
不包罗第四个参数指定的元素.
负值转化为: 负值 + 数老总度
*/

40、  Javascript创造对象的二种格局?

// splice(pos[, len[, a, b]]) 方法. 删除指定地方上马后,
指定长度元素, 再缀日币素;
// 重临删除元素结合的数组. 原数组改变.
var a = [1, 2, 3, 4, 5, 6, 7, 8];
a.splice(4); // [5, 6, 7, 8]; 此时 a: [1, 2, 3, 4]
a.splice(1, 2); // [2, 3]; 此时 a: [1, 4];
a.splice(1, 1); // [4]; 此时 a: [1];

1、var obj = {};(使用json创制对象)                                 
                              如:obj.name = ‘张三’;                 
                                                                   
​obj.action = function (){alert(‘吃饭’);}​;                           
                                    2、var obj = new
Object();(使用Object成立对象)                                       
  如:obj.name = ‘张三’;                                             
                                        ​obj.action = function
(){alert(‘吃饭’);}​;                                                 
              3、​通过构造函数成立对象。                             
                                          (1)、使用this关键字​如:   
                                                                     
    var obj = function (){                                           
                                                        this.name
=’张三’;                                                             
                                  this.age = 19;                     
                                                                     
          this.action = function (){                                 
                                                           
alert(‘吃饭’);                                                       
                                }​;}                                 
                                                                     
              ​(2)、使用prototype关键字如:                           
                                                function obj (){     
                                                                     
                      ​      obj.prototype.name =’张三’;             
                                                                 
​obj.prototype.action=function (){                                   
                                          alert(‘吃饭’);             
                                                                     
        }}​;                                                         
                                                             
4、使用内置对象创立对象。                                             
                          如:var str = new
String(“实例开始化String”);                                           
              var str1 = “直接赋值的String”;                         
                                                  var func = new
Function(“x”,”alert(x)”);        //示例初阶化func                     
      var obj = new Object();        //示例开头化一个Object

var a = [1, 2, 3, 4, 5];
a.splice(2, 0, ‘a’, ‘b’); // [1, 2, ‘a’, ‘b’, 3, 4, 5]
a.splice(2, 2, [1, 2], 3); // [‘a’, ‘b’]; 此时 a: [1, 2, [1, 2],
3, 3, 4, 5]
/* 注:
其次个参数后的参数, 直接插入到拍卖数组中。
第二个参数可为负数.
*/

// push() 方法和pop() 方法.
// push() 可以将一个或多少个新因素附加到数组的尾巴, 然后再次来到数组新长度;
// pop() 删除数组中的最终一个因素, 裁减数组的尺寸, 再次回到它删除的值.
// 注:四个主意都在原数组上改动, 而非生成一个修改过的数组副本.

var stack = [];
stack.push(1, 2); // stack: [1, 2]; return 2;
stack.pop(); // stack: [1]; return 2; 删除的元素值
stack.push(3); // stack: [1, 3]; return 2;
stack.pop(); // stack: [1]; return 3; 删除的元素值
stack.push([4, 5]); // stack: [1, [4, 5]]returm 2;
stack.pop(); // stack: [1]; return [4, 5]; 删除的要素值

41、事件绑定和平凡事件有何不一致

万般添加事件的措施:

var btn = document.getElementById(“hello”);

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

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

推行上边的代码只会 alert 2

事件绑定形式丰裕事件:

var btn = document.getElementById(“hello”);

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

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

施行上边的代码会先alert 1 再alert 2

平凡添加事件的法门不襄助添加多少个事件,最上边的事件会覆盖下面的,而事件绑定(add伊夫(Eve)ntListener)方式丰硕事件可以添加多少个。

add伊芙(Eve)ntListener不包容低版本IE

万般事件不可以废除

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

// unshift() 方法和 shift() 方法. 同上, 从数组头开端.

// toString() 方法和 toLocalString()
[1, 2, 4].toString(); // 1,2,3;
[‘a’, ‘b’, ‘c’].toString(); // ‘a,b,c’;
// 和无参数的 join 方法相同.

/* jsapi 新添方法:map, every, some, filter, forEach, indexOf,
lastIndexOf, isArray */

/* 类似数组的靶子 */

arguments
document.getElementsByTagName();

网站地图xml地图