1 对象

1）JS中为什么要用对象

函数的参数如果特别多的话，可以使用对象简化

function logLike(liao) {
    console.log(liao.name);
    console.log(liao.intro);
    console.log(liao.college);
    console.log(liao.site);
}

2）什么是对象

类和对象：
类
描述一类事物，相当于‘设计图纸’
JavaScript中可以自定义类，同时也提供了一个默认的类叫做Object
对象
描述一个具体的事物，相当于‘成品’。有自己的特征和行为

3） JS中的对象

JS中的对象是无序属性的集合
对象就是一组没有顺序的值，由一组组件值对构成
事物的特征在对象中用属性来表示
事物的行为在对象中用方法来表示

4） JS中对象的分类

内建对象（内置对象）
由ES标准中定义的对象，在任何的ES的实现中都可以使用（自带的、默认的）
比如：String````Number````Boolean````Function````Object````Math
宿主对象
由JS的运行环境提供的对象，现在主要指浏览器提供的对象
比如：BOM对象、DOM对象
自定义对象
自己创建的对象

5） 对象字面量

var Mrx = {
    //属性
    name:'明日香',
    age:19,
    sex:'女',
    //行为
    doMh:function () {
        console.log('LoveMrx');
    }
};
console.log(Mrx);
console.log.(typeof Mrx);    //Object

6） 常见创建对象的方式

对象字面量
（见上一个函数）
new Object()创建对象
可以先创建对象，需要用的时候再赋值，优势是节约内存。

var Mrx = new Object();
Mrx.name='明日香';
Mrx.age='19';
Mrx.sex='女';
console.log(Mrx);
console.log(typeof Mrx);

工厂函数常见对象

function Mrx(name,age,sex) {
    var p = new Object();
    p.name = name;
    p.age = age;
    p.sex = sex;
    p.doMh = function () {
        console.log('LoveMrx');
    };
    return p;
}
var x1=Mrx('MRX',19,'女')；
var x2=Mrx('LBL',18,'女')；
console.log(x1,x2);

自定义构造函数

function Hummn(name,age,sex) {
    this.name = name;
    this.age = age;
    this.sex = sex;
    this.doMh = function () {
        console.log('LoveMrx');
    }
    //return this；  //一般不写，是默认隐藏属性
}
var x1 = new Hummn('MRX',19,'女');
var x2=new Mrx('LBL',18,'女');
console.log(x1);
console.log(x2);

7） 属性和方法

属性
如果一个变量属于一个对象所有，那么该变量就可以称之为该对象的一个属性，属性一般是名词，用来描述事物的特征
方法
如果一个函数属于一个对象所有，那么该函数就可以称之为该对象的一个方法，方法是动词，描述事物的行为和功能

8） new关键字

new关键字一般和构造函数一起配合使用
构造函数
构造函数是一种特殊的函数
构造函数用于创建一类对象，首字母要大写
构造函数要和new一起使用才有意义

new做了哪些事情？
1-new先在内存中创建一个新的空对象
2-new会让this指向这个新的对象
3-执行构造函数，给这个新对象加属性和方法
4-返回这个新对象

9） this关键字

this是一个指针
特点：
1-普通函数执行，内部this指向全局对象window
2-函数在定义的时候this是不确定的，只有调用的时候才可以确定
3-如果函数作为一个对象的方法，被该对象所调用，那么函数内的this则指向该对象
4-构造函数中的this是一个隐式对象，类似一个初始化模型，所有方法和属性都挂载到了这个隐式对象身上，后续通过new关键词来调用，从而实现实例化

//普通函数
var str = '张三';
function func() {
    console.log(this);    //返回window
    console.log(this.str);    //返回张三
}
func();

//对象
var obj = {
    name='Mrx',
    age=19,
    func: function () {
        console.log(this);    //返回的是对象obj
        console.log(this.name);
        console.log(this.this);
    }
};
obj.func();

//构造函数
function Fn() {
    this.name = 'Mrx';
    this.age = 19;
    console.log(this);
}
Fn();    //this指向window
new.Fn();    //this指向对象Fn

10） 对象使用

遍历对象的属性

var Mrx = {
    //属性
    name:'明日香',
    age:19,
    sex:'女',
    //行为
    doMh:function () {
        console.log('LoveMrx');
    }
};
//访问对象的属性
console.log(Mrx['name']);    //[ ]里是字符串

//遍历对象 for···in···
for(var key in Mrx) {
    console.log(key);  //输出：name,age,sex,doMh
    console.log(key + ':' + Mrx[key]);    //输出name：明日香
}

删除对象的属性
delete关键字

//删除对象的属性
delete Mrx.age;
console.log(Mrx);    //没有age属性了

//增加对象的属性
Mrx.age = 30 ;
Mrx.friends = ['Lbl','Dzs'];
console.log(Mrx);

11） 基本类型和引用类型在堆栈中的表示

基本数据类型
基本类型又叫做值类型，在存储时，变量中存储的是值本身，因此叫做值类型
String Number ···
引用数据类型
复杂数据类型，在存储中，变量中存储的仅仅是地址（引用），因此叫做引用数据类型
Object
区别
JS中的变量都是保存到栈内存中的，基本数据类型的值直接在栈内存中存储，值与值之间是独立存在，修改一个变量不会影响其他的变量
对象是保存到堆内存中的，每创建一个新的对象，就会在堆内存中开辟出一个新的空间，而变量保存的是对象的内存地址（对象的引用），如果两个变量保存的是同一个对象引用，当一个通过一个变量修改属性时，另一个也会受到影响
堆和栈 （括号内为个人理解，不具备参考意义）
栈（有点像电脑内存）：由操作系统自动分配释放，存放函数的参数值，局部变量的值等
堆（有点像电脑硬盘）：存储复杂类型（对象），一般由程序员分配释放，若程序员不释放，由垃圾回收机制回收
注意！JS中没有堆和栈的概念，只是方标理解，存放方式是一致的

基本类型在内存中的存储（一变二不变）

var str1 = 'MRX';
var str2 = str1;
str1 = '变了';
console.log(str1);    //变了
console.log(str2);    //MRX

复杂类型在内存中的存储（一变大家变）

function Mrx(name,age,intro) {
    this.name = name;
    this.age = age;
    this.intro = intro;
}
var p1 = new Mrx('MRX',19,'Love Mrx');
var p2 = p1;
p1.name = 'LBL';
console.log(p2.name);  //LBL
console.log(p1 === p2);  //ture

基本类型作为函数的参数（一变二不变）
复杂类型作为函数的参数（一变大家变）

2 内置对象

概念：
JavaScript提供多个内置对象 String Math Array

Array对象

检查一个对象是否是数组

instanceof
//缺点是父代（Object）也会返回true
var arr = ['张三','李四']；
console.log(arr instanceof Array);    // true
console.log(arr instanceof Object);    //true

isArray()
//常用
var arr = ['张三','李四']；
console.log(Array.isArray(arr));    //true
console.log(Array.isArray('arr'));    //fales

toString()/ValueOf()
toString() 数组转换为字符串,逗号分隔每一项
valueOf() 返回数组对象本身

var arr = ['张三','李四']；
console.log(arr.toString());  //张三，李四
console.log(arr.valueOf() === arr);    //true

常用方法

join(separator) （加入）
将数组的元素组起一个字符串，以separator为分隔符，省略的话则默认用逗号为分隔符，该方法只接收一个参数：即分隔符
separator必须是字符串类型

var arr = ['张三','李四','王五']；
var str = arr.join('-');    //separator必须是字符串类型
console.log(str);    //张三-李四-王五

push()和pop()
push() 接受任意数量的参数，把他们逐个添加到数组末尾，并返回修改后数组的长度；
pop() 数组末尾移除最后一项，减少数组的length值，然后返回移除的项

var arr = ['张三','李四','王五']；
arr.push('小伙');
console.log(arr.push('小伙'))；    //4
console.log(arr);    //张三，李四，王五，小伙
arr.pop();
console.log(arr.pop())    //王五

shift()和unshift()
shift() 删除原数组第一项，并返回删除元素的值，如果数组为空则返回undefined
unshift() 将参数添加到原数组开头，并返回数组长度

var arr = ['张三','李四','王五']；
arr.shift();
console.log(arr.shift());    //张三
arr.unshift('大伙');
console.log(arr.unshift('大伙'));    //3

reverse()
反转数组项的顺序

var arr = [1,2,3,4,5];
arr.revese();
console.log(arr.revese());    //5,4,3,2,1

concat() （常用于网络请求，无限下拉菜单）
将参数添加到原数组中。这个方法会先copy一个当前数组，然后将接受到的参数添加到这个copy数组的末尾，最后返回新构建的数组。在没有给concat()方法传递参数的情况下，他只是复制当前数组并返回

var arr = [1,2,3,4,5];
var arr1 = [7,8];
var arr2 = [9];
var newArr = arr.concat(arr1);
console.log(newArr);    //1,2,3,4,5,6,7,8
var newArr2 = arr.concat(arr1,arr2);    //1,2,3,4,5,6,7,8,9
var newArr3 = arr.concat(arr1,arr2,'张三丰');    //1,2,3,4,5,6,7,8,9,张三丰

indexOf()和lastindexOf() index=索引 （常用于获取文件后缀名）
格式： indexOf(你要找的东西，从哪个位置开始找)；

var arr = [1,2,3,3,2,1];
arr.indexOf(2);
console.log(arr.indexOf(2));    //1
arr.indexOf(2,2);    //4
arr.lastindexOf(1);    //5
arr.lastindexOf(1,1);     //0

forEach() （常用于遍历数组）
这个方法只支持IE8以上的浏览器，所以如果需要兼容IE8，则不要使用forEach，还是使用for循环来遍历
数组中有几个元素，函数就会执行几次，每次执行时，浏览器会将遍历到元素以实参的方式传递进来，我们可以来定义形参，来读取这些内容
forEach(function (所有内容，内容对应索引，数组本身){})

var arr = ['张三','李四','王五']；
arr.forEach(function (value,index,array) {
    console.log(value);
    console.log(index);
    console.log(array);
});

ES6新增

sort() sort=排序
sort方法用于对数组的元素进行排序，默认是按照字符编码的顺序进行排序
如果想按照其他标准进行排序，就需要提供比较函数，该函数要比较两个值，然后返回一个用于说明这两个值的相对顺序的数字，比较函数应该具有两个参数a和b
若a小于b，在排序后的数组中a应该出现在b之前，则返回一个小于0的值
若a等于b，则返回0
若a大于b，则返回一个大于0的值

function sortNumber(a,b) {
    return a - b    //可能会有  >0  =0  <0  三种可能,从小排到大
    return b - a    //从大排到小
}
var arr = [10，20，5，1000，50]；
arr.sort();    //10,1000,20,5,50
arr.sort(sortNumber);    //5,10,20,50,1000

实现方式(冒泡排序)

var arr = [10，20，5，1000，50]；
function sort(array,fuCompare) {
    //控制循环的次数
    for  (var i = 0; i < array.length - 1 ; i++) {
        //标记    是否完成排序
        var sortFlag = true；
        //控制比较次数
        for(var j = 0; j<array.length - 1 - i; j++) {
            if(fnCompare(array[j],array[j+1]) > 0) {
                sortFlag = false;
                //交换位置
                var  temp = array[j];
                array[j] = array[j+1];
                array[j+1] = temp;
            }
        }
        //判断
        if(sortFlag) {
            break;
        }
    }
}
function sortNumber(a,b) {
    return b - a;
}
sort(arr,sortNumber);
console.log(arr);

map()
映射（一一对应），[].map()基本用法跟forEach方法类似：array.map(callback,[thisObject]);
但是callback需要有return值（如果没有，就会返回undefined）

var arr = [10，20，5，1000，50]；
var newArr = arr.map(function (value,index,array) {
    return value * 2;
    return value > 10 && value * 2;
});
console.log(newArr);      //输出[20,40,10,2000,100]
console.log(newArr);       //[false,40,false,2000,100]

filer()
过滤筛选
callback在这里担任的时过滤器的角色，当元素符合条件，过滤器就会返回true，而filter则会返回所有符合过滤条件的元素

var arr = [1,2,3,4,5,6,7,8]
varr newArr = arr.filter(function (value,index,array)  {
    return value % 2 ===0;
    return value % 2 ===0 && value > 5;
});
console.log(newArr);    //[2,4,6,8]
console.log(newArr);    //[6,8]

every(且)
一假则假
会返回布尔类型的值

var arr = [11,2,3,4,15];
var result = arr.every(function (value,index) {
    return value > 1;
    return value > 4;
});
console.log(result);    //true
console.log(result);    //fales

some(或)
一真为真

var arr = [11,2,3,4,15];
var result = arr.some(function (value,index) {
    return value > 4;
});
console.log(result);    //true

Math对象

概念
Math对象不是构造函数，它具有数学常数和函数的属性和方法，都是以静态成员的方式提供

常用方法

Math.PI      //圆周率
Math.random()    //生成随机数
Math.floor()/Math.ceil()    //向下取整/向上取整
Math.round()    //取整，四舍五入
Math.abs()    //绝对值
Math.max()/Math.min()    //求最大和最小值
Math.sin()/Math.cos()    //正弦/余弦
Math.power()/Math.sqrt()      //求指数次幂/求平方根

console.log(Math.PI);    //输出圆周率：3.1415926
Math.ceil(Math.PI);    
console.log(Math.ceil(Math.PI));    //
console.log(Math.random());    //0-1之间的随机数
console.log(Math.random()*10);    //0-10之间的随机数

Math.random() * (y - x) + x ;
//分解：Math.random() = (0,1)
//8 - 3 = 5
//(0,1) * (8 - 3) + 3 = (3,8)
//(0,1) * 5 + 3 = (3,8)
Math.random() * (8 - 3) + 3 ;    //3-8之间的随机数

静态成员和实例成员
静态成员：直接使用对象来调用
实例成员：构造函数中的成员就是实例成员 实例也称为对象

String对象

概念
字符串所有的方法，都不会修改字符串本身（字符串是不可变的），操作完成会返回一个新的字符串
拼接大量字符串的时候，会有性能问题

常用方法

获取字符串中字符的个数
str.length

字符方法
charAt() 获取指定位置处字符
charCodeAt() 获取指定位置处字符的ASCII码

var str = 'i love Mrx';
console.log(str.charAt(3));   //o 
//获取所有字符和ASCII码
for (var i = 0; i < str.length; i++) {
    console.log(str.charAt(i));
    console.log(str.charCodeAt(i));
}

字符串操作方法
concat() //拼接字符串，+更常用
substr() //从start位置开始，截取length个字符

var str = 'i love Mrx.exe';
var newStr = str.substr(2,5);
console.log(newStr);    //love
var newStr = str.substr(str.lastIndexOf(.));    
console.log(newStr);    //.exe
var newStr = str.substr(str.lastIndexOf(.) + 1);   
console.log(newStr);    //exe

去除空白 trim() 只能去除字符串前后的空白

var str = '       i love Mrx.exe       ';
console.log(str.trim());    //去除前后空格

大小写转换
toUpperCase() 转换大写
toLowerCase() 转换小写