数 组 ---- 特殊的 对象
定义方法:
1. var a = [ 里面可放值 ]; 自变量形式
2. var arr = new Array( 里面可传参数 );
当 new Array()的参数只有一个时,此时不能传小数,此参数就变成数组的长度
数组 能用的一切 方法 都来源于 Array.prototype 提供
数组 的 读 和 写:
- arr[num] ----- 不可溢出读,结果为 undefined
- arr[num] = xxx ——————> 可以溢写,是那么都可以溢出
数 组 的 方 法 :
改变原数组:
-
push(一或多参数)— 在数组的 最后 一位 添加 值
// 自己编写的 push 方法 var arr = [1,2,3]; Array.prototype.push = function (){ for (var i = 0; i < arguments.length; i++) { this[this.length] = arguments[i]; } return this.length; }
- pop(无参)---- 将数组 最后一位 剪切 出来
- shift (无参) ------ 在数组的 最前位 剪切 值
- unshift (无参) ---- 在数组的 最前位 添加 值
- sort (无参) ---- 将数组内的值按字符ASCII值 升序 排列
sort (无参).reverve (无参) ---- 按字符ASCII值降序 排列
sort( ) 方法 的改写
var arr = [1,3,5,4,10];
// 由于原来的方法不满足我们的正常需求,因此可以改写 sort() 方法
// sort( 为用户保留了一个接口 ,改写后系统会在适合的时机调用)
// 改写 要求 规则 :
// 1.必须写两个形参
// 2.看返回值
1)当返回值为 负数 时,前面 的数放在 前面
2)当返回值为 正数 时,后面 的数在 前面
3)当返回值为 0 时,不动
arr.sort(function (a , b){
// 实际符合 冒泡排序,每轮都把最小的数放在前面
if(a > b){
return 1;
}else{
return -1;
}
// 上述方法简化为 三木运算
//return (a > b ? 1 : -1) ;
// 或者直接返回,更简洁
//return a-b; });
// 给一个有序的数组 乱序,即每次执行后的值顺序都不一致
var arr = [1,2,3,4,5,6,7];
arr.sort(function (){
return Math.random() - 0.5;
});
- reverve (无参) — 改变数组内值的顺序,逆转
- splice (从第几位开始,截取多少长度 ,在切口处添加新的数据) — 剪切
不改变原数组:
- concat(有参) — arr.concat(arr1) —> 把两个数组内的值链接,形成一个新数组
- join(" 参数必须是字符串原始值,返回的结果为字符串类型 ") -----> 将数组里的每个数,用参数链接起来, 不传参数时,按 逗号 链接
- split(‘参数必须是字符串原始值,返回的结果为数组’) ----> 与 join() 作用互逆,按参数形式进行拆分
- toString(无参) ——> arr.toString() 将 arr 里的值转化为 字符串类型 也证明了 Array 数组 已经重写了 toString() 方法
- slice (有参 也可 无参):
1)两位参数 arr.slice(从该位开始截取,截取到此位) 必须要有变量接收其值
var newArr = arr.slice(1,3);
2)一位参数 arr.slice(从该位开始,一直截取到最后一位)
3)参数为 负数 时,具体位数的结果 = 负数值 + 数组的长度
4)无参数时,截取整个数组
类 数 组 ———— 像数组,但就不是数组,没有数组拥有的方法
构建 类数组
好处: 把 对象 和 数组 的方法链接到一起
属性要为索引(数字)属性,必须有 length 属性,最好加上 push
var obj = {
'2' : 'c',
'3' : 'd',
'length' : 2,
'push' : Array.prototype.push,
// 加了此方法后,类数组 就可以当作数组一样用了
'splice' : Array.prototype.splice
}
// 类数组 push() 方法内部原理
Array.prototype.push = function (target){
obj.[obj.length] = target;
obj.length ++;
}
作 — ---------------------- — 业
封装 type() 方法
由于 typeof() 方法 返回的类型并不准确,因此要封装
typeof( [ ] ) ----> array
typeof( { } ) ----> object
typeof( function ) ----> object
typeof( new Number() ) ----> number Object
typeof( 123 ) ----> number
1.分两类 : 原始值 和 引用值
2. 区分引用值
var type = function (target){
var template = {
'[object Array]' : 'array',
'[object Object]' : 'object',
'[object Number]' : 'number-object',
'[object Boolean]' : 'boolean-object',
'[object String]' : 'string-object'
}
if(target === null){
return 'null';
}else if(typeof(target) == 'object' ){
// 数组 对象 包装类
var str = Object.prototype.toString.call(target);
return template[str];
}else {
return typeof(target);
}
}
数 组 去 重
要求在原型链上编程利,用 对象 统一属性名 不能有多个属性值的特点,
把数组里的每一位值,当作同一个 对象的 属性名
var arr = [1,1,1,2,2,2,3,3,3,4,4];
Array.prototype.unique = function() {
var temp = {},
arr = [],
len = this.length;
for (var i = 0; i < len; i++) {
if( !temp[this[i]] ){
temp[this[i]] = 'abc';
arr.push(this[i]);
}
}
return arr;
}
字 符 串 去 重
var str = '111222333';
String.prototype.alone = function (){
var a = this.split(" ");
var temp = {},
arr = [];
for (var i = 0; i < this.length; i++) {
if(temp[a[i]] == null){
temp[a[i]] = 'a';
arr.push([a[i]]);
}
}
return arr+" ";
}
try {
} catch(e) {
// 捕 捉 异 常
}
// 在 try 里面的代码 ,若发生错误
// 不会执行错误后的在 try 中的代码
try{
console.log('a');
// 此处出错
console.log(b);
console.log('c');
} catch(e){
// error error.message error.name --> error
console.log(e.namee + ":" + e.message );
}
console.log('d');
Error.name 的六种值对应的信息:
- EvalError : eaval() 的使用与定义不一致 (基本不常见)
- RangeError : 数值越界
- ReferenceError : 非法或不能识别的引用数值 // 最常见(未定义就使用)
- SyntaxError : 发生语法解析错误 (最常见)
- TypeError : 操作数类型错误
- URIError : URI(引用地址)处理不当