js总结之对象和内置对象

对象和内置对象

Object
对象就是属性的无序集合。数组是有序集合。

1. 创建对象的方法

• 自定义对象

var dog = {
            2: 'iii',//dog[2]，不能dog.2
            age: 2,//访问用dog.age / dog['age']
            sex: '公',//2、age、sex属于静态体征
            eat: function () { console.log(this.age) }//eat属于动态行为(即方法）
        }

• 通过new Object()创建

var erha = new Object()//erha代表的是实例对象
        erha.age = 2;//给实例对象添加属性
        erha.sex = '公';
        erha.eat=function(){}//对象方法  调用 erha.eat()

2. 内置对象（定义好了属性和方法的对象 js内置）

数组：是一个连续的存储空间

定义数组

• 数组的对象表达式

   var arr=naw Array(8,5,7)
   console.log(arr);
   var arr=naw Array(8)//有且只有一个数字时，代表给数组设置长度 如：var arr=naw Array(7)

• 字面量形式

var arr=[1,2,3]
var arr=[1,,,,3]//稀疏数组//没有给值得访问返回值为underfined

访问数组的长度

arr.length

数组的方法

• push() 在数组最后一位添加，可以添加多个

   arr.push(1）
   arr.push(1，2，3）

• pop()删除数组得最后一位

   arr.pop()

• unshift() 第一位添加

   arr.unshift(1)

• shift() 删除第一位

   arr.shift()

• splice(start,delectCount) 删除指定位置

   arr.splice(1,1)

• splice(start,Count,newVallue) 在指定位置替换

   arr.splice(1,1,'pear')

• splice(start,0,newVallue) 插入

   arr.spice(1,0,'pear')

• reverse() 颠倒顺序

   arr.reverse()

• sort() 排序(按照字符来比）

   arr.sort()

• 比值函数

arr.short(function(a,b){return a-b})

• 对对象采用比值函数

var obj = [
            { name: 'aaa', age: 23 },
            { name: 'bbb', age: 22 },
            { name: 'ccc', age: 19 },
            { name: 'ddd', age: 20 },
        ]
        obj.sort(function (a, b) {
            return a.age - b.age
        })
        console.log(obj);

• concat() 连接，不会改变原数组，用另一个数组来拿到返回值

 var arr=[1,2,3],arr2[2,3,4]
     arr.concat(arr2)
     console.log(arr);
     console.log(arr2);
     var arr3=arr.concat(arr2)//拿到返回值
     console.log(arr3);

• join() 拼接为一个字符串，不会改变原数组，用另一个数组来拿到返回值

var arr=['苹果','荔枝','西瓜']
     arr.join('|')
     console.log(arr);
     var str=arr.join('|')
     console.log(str);

• toString() 将数组转为字符串，不会改变原数组，用另一个数组来拿到返回值

var arr=[1,2,3]
     var str=arr.toString()
     console.log(str);//1,2,3

• slice() 截取，从strat开始，end结束(不包含end)，不会改变原数组，用另一个数组来拿到返回值

var arr=[1,2,4,3,6]
     var arr2=arr.slice(2,4)
     console.log(arr2);//打印出4，3，从指定位置开始
     var arr3=slice();//拷贝数组
     console.log(arr==arr3);

• Array.isArray()判断是否是一个数组

 var arr=[]
     console.log(typeof arr);
     console.log(Array.isArray(arr));

• indexOf 查找数组是否有指定值

var arr=[1,3,2,5,4,6,2]
     console.log(arr.indexOf(5));//查找数组中值为5的下标，返回对应下标 否则-1
     console.log(arr.indexOf(2,3));//第二个参数表示从第n位开始查找

pop push splice shift unshift的 返回值是多少？

 var arr=[1,2,3]
     var result=arr.push(4,'haha')//push的返回值是长度
     console.log(arr);
     console.log(result);
     var result=arr.pop()//pop()的返回值是删除的这个值
     console.log(result);
     var result=arr.splice(1,2,'hehe')//删除的值组成的数组
     console.log(result);
     var arr=[1,2,3]
     var result=arr.splice(1,0,'hehe')//空数组
     console.log(result);

遍历

• 第一种：

  var arr=['ATM','BMW','API']
     for(var i=0;i<arr.length;i++){
     console.log(arr[i]);
     }
     for(var i=0,len=arr.length;i<len;i++){
     console.log(arr[i]);
     }

• 第二种：for…of

for(var item of arr){
     console.log(item);
     }

• 第三种：for…in //稀疏数组中，遇到undefined时，不会打印，直接打印有值的，即跳过稀疏数组

//遍历对象
     var obj={age:20,sex:'nv'}
     for(var key in obj){
     console.log(obj[key]);
     }

 //遍历数组
     var arr=['ATM','BMW','API']
     for(var key in arr){
     console.log(arr[key]);
     }    

• 第四种：forEach()// forEach等方法 也会跳过稀疏数组

var arr=['ATM','BMW','API']
     var result=arr.forEach(function(value,index,originArray){
     console.log(value,index,originArray);
     })
     console.log(result);//undefined 没有返回值

• filter() 过滤，满足条件的值组成的新数组

var phone = [
            { name: '小米', price: 1000 },
            { name: 'vivo', price: 3000 },
            { name: 'oppo', price: 2000 },
            { name: '苹果', price: 4000 },
            { name: '华为', price: 5000 },
        ]
        var result = phone.filter(function (value, index, arr) {
            return value.price >= 3000
        })
        console.log(result);

• map() 遍历器，返回一个通过计算得到的新数组

var arr=[2,3,1,6]
     var result=arr.map(function(value){
     return value+2
     })
     console.log(result);//返回一个数组，结果为所有值都加了2 

• every() 数组中的所有值满足条件才返回true，否则false

var arr=[2,3,5,6,-1]
     var result=arr.every(function(value){
     return value>0
     })
     console.log(result);//true

• some() 数组中的有一个值满足条件就返回true，否则false

 var arr=[2,3,5,6,-2]
     var result=arr.every(function(value){
     return value>0
     })
     console.log(result);//true

数组去重

 var arr = [1, 2, 3, 4, 4, 4, 4, 5, 2, 3]
        function uniq(arr) {
            var resultArr = []
            for (var i = 0; i < arr.length - 1; i++) {
                if (resultArr.indexOf(arr[i]) == -1) {//代表数组里面没有的
                    resultArr.push(arr[i])
                }
            } return resultArr
        } console.log(uniq(arr));

随机数

var num=Math.random()//0-1的小数
var num=Math.random()*10//0-10的小数
var num=parseInt(Math.random()*10+20)//20-30的整数 Math.random()*(大-小)+大