数组、类数组、typeof 类型转换

数组的定义

字面量 var arr = [1,2,3,a,g,d,first,undefined…];
构造方法 var arr = new Array(length/content);

数组的读写
arr[num]
arr[num]

数组中常用方法

改变原数组 在原数组上操作
.push(num1,num2,num3…) 在数组的最后添加数据

.pop( ) 把数组最后一位剪切

.shift( )

.unshift(num1,num2,num3… ) 在数组的前面添加数据

.reverse( ) 将该数组反序

.splice(从第几位开始,截取多少长度,在切口添加新的数据1,在切口添加新的数据2…)

.sort( ) 根据asc码排升序，提供函数接口可按需设计排序

sort()里写的函数规则：
1.必须写俩形参；
2.当返回值是负数，前面的数放前面；为正数，前面的数放后面；为0不动

var arr = [23,43,55,63,3,2,9];
arr.sort(function(a,b) {
//return a-b; 升序
//return b-a; 降序
}

//给一个有序数组，乱序
var arr = [1,2,3,4,5,6];
arr.sort(function() {
return Math.random( ) - 0.5;
});

不改变原数组 返回新数组
concat join —> split toString slice

.concat( ) 将两个数组拼接
var arr = [1,2,3],
arr1 = [4,5,6];
//因为不改变原数组并且返回新数组所以要拿变量接收
var newArr = arr.concat(arr1) —> [1,2,3,4,5,6]

.slice(从该位开始截取，截取到该位之前)
//只填一个参数就从该位截取到最后，无参数全部截取
var arr = [1,2,3,4,5,6];
var newArr1 = arr.slice(1,3) —> [2,3]

.join(‘写哈用哈链接,不写用逗号，写空串直接连’) 返回字符串
var arr = [1,2,3,4,5];
var newArr = arr.join(’~’); —> ‘1₂3₄5’

.split(‘写哈用哈拆分，且写的是该数组里有的’) 返回数组
var str = ‘1₂3₄5’;
var arr = str.split(’~’); —> [‘1’,‘2’,‘3’,‘4’,‘5’]

typeof 类型转换 typeof( )

number string boolean object undefined function

显示类型转换
//类型变成number类型，null->0 bool->0/1 undefined->NaN
// 转换不成数字的->NaN
Number(mix)

//识别数字开头的和第一个小数点的数
//parseFloat(‘123.45.5.1abc’) -> 123.45
parseFloat(string)

//转换成整型 parseInt(12.3) -> 12 parseInt(‘123.5abc’) -> 123
//俩参数时，以目标进制为基底转换成10进制的数 parseInt(string,基底)
//基底取值范围2-36，2进制到36进制，前一个参数要符合基底，否则NaN
parseInt(string,radix)

//parseFloat(‘123.45.5.1abc’) -> 123.45
parseFloat(string)

//如果谁想变成字符串，谁就用点调用toString( ) num.toString( )
//undefined和null不能用
//参数是基底，把10进制的数转换成目标基底的数
//var num = 10; num.toString(8) -> 12
toString(radix)

//把参数变成字符串类型
String(mix)

//把参数转换成bool类型，其它为true
//被认定为false的值：undefined , null , NaN , “” ， 0 , false
Boolean( )

隐式类型转换
isNaN( ) --> 隐式调用Number( );
++、–、正负号+、- --> 隐式调用Number( );
+ 当加号两边有一个是字符串类型就会调用String( );
-、*、/、% --> 隐式调用Number( );
&& || ! 隐式调用Boolean( );
< > <= >= 数字和字符串比隐式调用Number( );
== !=

没有隐式类型转换
===
!==

类数组

可以利用属性名模拟数组的特性
可以动态的增长length属性
如果强行让类数组调用push方法，则会根据length属性的位置进行属性的扩充

类数组的特性是把对象和数组的属性拼到一起
类数组属性要为索引（数字）属性，必须有length属性，最好加上push

        var obj = {
            '0': 'a',
            '1': 'b',
            '2': 'c',
            name: 'abc',
            age: 123,
            length: 3,
            push: Array.prototype.push,
            splice: Array.prototype.splice
        }

实例

封装type

        // typeof ([]) -- - array
        // typeof ({}) -- - object
        // typeof (function) -- - object
        // typeof (new Number()) -- - number Object
        // typeof (123) -- - number

        function type(target) {
            var ret = typeof (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 (ret == 'object') {
                var str = object.prototype.toString.call(target);
                return template[str];
            } else {
                return ret;
            }
        }

数组去重

原型链上编程

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

其他

当且仅当一个未定义的变量放在console.log(typeof(a))中不报错
typeof( )返回值的类型是string
NaN不与自身相等且不与任何值相等
字符串和字符串比较的是ASC码
arguments实参列表是个类数组