引用类型基本使用

摘要：引用类型类型创建实例用的少等价于操作符字面量表示法这里的称为属性，属性名可以用字符串。函数返回的值作为下一次的第一个参数使用，依次遍历数组，直至结束。

创建实例：

</>复制代码 
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 + "
"
   console.log(args.name)
}
if( typeof args.age == "number") {
    output += “Age: " + args.age + ”
“ 
    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

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

</>复制代码 
var names = ["xiaoming", "xiaoqiang", "xiaojun"]
names.length = 1
console.log(names)
// ["xiaoming"]
names.length = 4
console.log(names)
//["xiaoming", undefined, undefined, undefined]
// 数组的length 属性可以去除和添加项

检测是否为数组

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

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

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

</>复制代码 
var names = ["xiaoming", "xiaoqiang", "xiaojun"]
console.log(names.pop()) //["xiaojun"]
console.log(names) // ["xiaoming", "xiaoqiang"]

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

</>复制代码 
var names = ["xiaoming", "xiaoqiang", "xiaojun"]
console.log(names.push("dalong")) // 4
console.log(names) // ["xiaoming", "xiaoqiang","dalong"]

取出数组第一项并返回

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

</>复制代码 
var values = [1,2,3,4,5]
values.reverse()
console.log(values) // 5,4,3,2,1

默认将数组进行从小到大排序，但比较的是项的字符串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(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"

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

</>复制代码 
var colors = ["red", "green", "blue", "black", "yellow", "brown"]
var colors2 = colors.slice(1,3) //["green","blue","]

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

</>复制代码 
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()： 从数组末尾开始查找，第二个参数是于末尾位置向前

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

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()方法：从后往前开始

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

此为看书笔记，仅作为本人备忘使用，如有谬误，欢迎指正 。