引用类型基本使用

引用类型

Object类型

创建实例：

var person = new Object() （用的少）等价于 var person = {}
person.name = 'kangkang'
person.age = 18
// new 操作符

var person = {
  name:'kangkang',
  age:18,
  6:true
}
// 字面量表示法
//这里的name 称为属性，属性名可以用字符串。参见json

将必须的参数存储

function displayInfo(args) {    
  var output = ''
  if(typeof args.name == 'string') {
  output += “Name: " + args.name + "\n"
   console.log(args.name)
}
if( typeof args.age == 'number') {
    output += “Age: " + args.age + ”\n“ 
    console.log(args.age)
 }
 console.log(output)
}
displayInfo({
    name:'kangkang',
    age:18
})
displayInfo({
    name:'kangkang'
})

当一个函数需要有大量的参数以供使用时，但不是所有都是必须的，那么这样写就会提供很大便利，将经常用到值使用命名参数（比如如果name和age经常用到）处理，使用对象字面量封装多个可选参数以供使用。

访问属性

属性的访问一般使用点号，也可以使用方括号属性名要加引号，不过有一个就是属性名为数值时要用方括号并且无需引号括起来(括起来也行),特殊的属性名需要用引号包围起来（比如第一个字符为数字，或者含有空格或运算符）. 属性的书写也基本遵循上面规则，保留字比如class则可以用作属性名并且不加引号。

var person = {
  name:'kangkang',
  "age":18,
  6:true
  '1a': "no",
  'a b': "i",
  'p+q': "go"
}

console.log(person.age) // 18
console.log(person['age']) // 18
console.log(person[6]) // true
console.log(['6']) //true

Array 类型

JavaScript 中的数组可以保存不同类型的数据
创建方法

Array 构造函数
字面量方法

var apples = Array(3) // 包含3个 undefined 的的数组
var age = [3] //包含一个数值3 的数组

console.log(apples) //[undefined, undefined, undefined]
console.log(apples.length)  // 3

console.log(age) // [3]
console.log(age) //1

访问数组数值

通过索引访问

var names = ['xiaoming', 'xiaoqiang', 'xiaojun']
name[0]~ name[2]
console.log(names.length) // 3

length的使用

var names = ['xiaoming', 'xiaoqiang', 'xiaojun']
names.length = 1
console.log(names)
// ["xiaoming"]

names.length = 4
console.log(names)
//["xiaoming", undefined, undefined, undefined]

// 数组的length 属性可以去除和添加项

Array.isArray(names)

检测是否为数组

转换为数组

names.toString()

返回一个数组各项以逗号隔开的一个字符串（注意是组成了一个字符串）

names.join('-')

以指定分隔符分割数组的项并返回组成的一个字符串，不传或者传入undefined 都将使用逗号分割

操作数组的项

pop() 方法

栈方法，先进后出。弹出最上面的项(既然是弹出，就会返回弹出的值),无需参数。

var names = ['xiaoming', 'xiaoqiang', 'xiaojun']

console.log(names.pop()) //["xiaojun"]
console.log(names) // ["xiaoming", "xiaoqiang"]

push() 方法

栈方法，先进后出。推入，将参数依次推入栈中，数据添加到数组末尾，返回最终数组长度。

var names = ['xiaoming', 'xiaoqiang', 'xiaojun']

console.log(names.push('dalong')) // 4
console.log(names) // ["xiaoming", "xiaoqiang","dalong"]

shift() 方法

取出数组第一项并返回

unshift() 方法

按参数中顺序将值添加到数组开头并返回个数

reverse() 方法

var values = [1,2,3,4,5]
values.reverse()
console.log(values) // 5,4,3,2,1

sort() 方法

默认将数组进行从小到大排序，但比较的是项的字符串Unicode位点进行排序，就会出现数值比较时的错误，所以可以传递一个比较函数来指定排布方式

function compare (value ,value2) {
  if(value < value2){
    return -1
}else if (value > value2) {
    return 1
}else {
    return 0
  }
}
// 这是升序排列的比较函数

function compare (value,value2){
   return value - value2
}

function compare (value,value2){
   return value > value2
}
// 这两种形式均是从小到大排列的简写形式

比较函数的机制： sort接受true 和false ，对数组每一项按函数迭代比较，如上面代码，若第一个参数（项）小于第二个参数（项），如果想转换位置则返回true，sort接受到true后进行位置交换。返回false则位置不变。

splice方法

这是一个很强大的数组方法

删除 `splice(2, 2)`

可以删除任意的项，接受两个参数，第一个是起始位置，第二个是删除的项数(不是结束位置),返回被删除的项

插入 `splice(2, 0, 2)`

向指定的位置插入任意数量的项，接受三个参数，分别是起始位置，要删除的项数（0项），要插入的项（可以是多个项）

替换 `splice(2, 2, "a","b")`

这个替换，可以不是等数量项的替换，执行的是先删除再插入的操作，接受的参数分别是，起始位置、要删除的项数、要插入的项。注意到这里要删除的项数如果是0就变成了只有插入功能了。

var colors = ["red", "green", "blue", "black"]

console.log(colors.splice(0,1)) //["red"]
console.log(colors) // ["green", "blue", "black"]
// 删除从0 开始一个项

colors.splice(0,0,'yellow')
console.log(colors) // ["yellow", "green", "blue", "black"]
// 在0位置插入'yellow'，项依次后移

colors.splice(1,2,'brown')
console.log(colors) // ["yellow", "brown", "black"]
// 从 1 开始删除两个项，并插入项' brown'

slice()

裁剪，可以接受一个或者两个参数，第一个参数是起始位置，第二个是结束位置（不包括这个项），若只有一个参数，则作为起始位置并至数组末尾，取出起始位置到结束位置的项作为一个新数组返回，不影响原数组。

var colors = ["red", "green", "blue", "black", "yellow", "brown"]
var colors2 = colors.slice(1,3) //['green','blue',']

concat(array)

拼接，可以把参数作为值添加到数组的末尾，如果这个参数是一个数组，则会将数组中的值拿出添加进去，返回一个被改变的新数组，原数组不变

var colors = ['red','green','blue']
var colors2 = colors.concat('black',['yellow','brown'])


console.log(colors) // ["red", "green", "blue"]
console.log(colors2) // ["red", "green", "blue", "black", "yellow", "brown"]

indexOf() 方法 lastIndexOf()方法

均接受两个参数，分别是要查找的项和起始位置

indexOf()：从数组开头查找，第二个参数相对于开头位置
lastIndexOf()：从数组末尾开始查找，第二个参数是于末尾位置向前

迭代方法

接受函数作为参数，运行在数组每一项上，接受的函数又可以接受三个形式参数分别作用是：
迭代的值、该项在数组的位置（索引）、数组本身

every()

对数组每一项运行给定函数，只有每一项在函数运行后均为true，函数才返回true

filter()

对数组每一项运行给定函数，返回一个由项在运行后且结果为true的项组成的新数组（过滤效果）

var numbers = [1,2,3,4,5,6,7,8,9]
var filterResult = numbers.filter(function(item, index ,array){
  return (item >2 )
})
console.log(filterResult)

forEach()

对数组每一项运行给定函数，没有返回值

var numbers = [1,2,3,4,5,6,7,8,9]
numbers.forEach((n,index)=> {
 numbers[index] += 2
 
})
console.log(numbers)
// [3, 4, 5, 6, 7, 8, 9, 10, 11]

map()

每一项运行函数，且返回运行后的每一项组成的数组

var numbers = [1,2,3,4,5,6,7,8,9]
var mapResult = numbers.map((n)=> {
 numbers[index] += 2 //修改原数组的值
 return n*2 //返回给新数组的对应索引的值
})
console.log(mapResult)
// [2, 4, 6, 8, 10, 12, 14, 16, 18]

some()

对每一项运行函数，只要有一项运行结果为true，则器结果返回true

reduce()方法和 reduceRight()方法

归并，接受两个参数：调用的函数和可选的初始值。调用的函数接受四个参数：前一个值，当前值，索引，数组对象（这个有时会用到）。如果设置了初始值，就用初始值和第一项作为函数的参数，如果没有则是前两项。函数返回的值作为下一次的第一个参数使用，依次遍历数组，直至结束。

reduce()方法：从前往后开始
reduceRight()方法：从后往前开始

var values = [1,2,3,4,5]
var sum = values.reduce(function(prev, cur, index, array){
  return prev+cur
})
// 这是一个求和的操作