JavaScript学习笔记二

七、对象

1.对象简介

如果使用基本数据类型的数据，我们所创建的变量都是独立的，不能成为一个整体，而对象属于一种复合的数据类型，在对象中可以保存多个不同数据类型的属性

对象的分类：

1）内建对象：

由ES标准中定义的对象，在任何的ES的实现中都可以使用（比如：Math Sting Number Boolean......）

2）宿主对象：

由JS的运行环境提高的对象，目前来讲主要指由浏览器提供的对象（比如：BOM DOM）

3）自定义对象：

由开发人员自己定义自己定义

2.对象基本操作

四项基本操作：增、删、改、查

//创建对象
var obj = new Object();
/*
使用new关键字调用的函数是构造函数constructor
而构造函数是专门用来创建对象的
*/
​
//向对象中添加属性
//语法：对象.属性名 = 属性值
obj.name = "孙悟空";
obj.gender = "男";
​
//读取对象中的属性
//语法：对象.属性名
console.log(obj.name); //孙悟空
/*
若读取对象中没有的属性，不会报错，但会返回undefined
*/
console.log(obj.age); //undefined
​
//修改对象属性值
//语法：对象.属性名 = 新值
obj.name = "猪八戒";
console.log(obj.name); //猪八戒
​
//删除对象中的属性
//语法：delete 对象.属性名
delete obj.name;

3.对象中的属性名和属性值

属性名：

对象中的属性名不强制要求遵循标识符的规范，但还是尽量按照标识符的规范使用

/*
如果要使用特殊的属性名，不能采用.的方式来操作
而需要使用另外一种方式
    语法：对象["属性名"] = 属性值
*/
obj.123 = 789; 
console.log(obj.123); //报错
​
obj["123"] = 789; 
console.log(obj[123]); //没有问题（怎么设置属性值就怎么读取属性值）
// 而且使用[]这种形式去操作属性，更加的灵活
obj["nihao"] = "你好";
n = 123;
console.log(obj[n]); //789
n = "nihao";
console.log(obj[n]); //你好

属性值：

属性值可以是任意的数据类型

in 运算符：

/*
in 运算符
    通过该运算符可以检查一个对象中是否含有指定的属性
语法："属性名" in 对象
*/
console.log(obj.age); //false
console.log(obj.gender); //true

4.创建对象的另外方式

1）使用字面量来创建对象

/*
使用对象字面量，可以在创建对象时，直接指定对象中的属性
语法：{属性名：属性值，属性名：属性值......}
对象字面量的属性名可以加引号也可以不加，建议不加
如果要使用一些特殊的对象名，则必须加引号
*/
var obj = {
    name:"张三",
    age:18,
    gender:"男"
    "!@#$":123  //特殊对象名
}

2）使用工厂方法创建对象

/*
使用工厂方法创建对象
    通过该方法可以大批量的创建对象
    但该方法所创建的对象都属于Object，无法进一步区分，所有不推荐使用
*/
function createObj(name,age,gender){
    var obj = new Object();
    obj.name = name;
    obj.age = age;
    obj.gender = gender;
    return obj; //注意：需要将新对象返回
}
var obj = createObj("张三",18,"男")
var obj2 = createObj("李四",28,"男")
var obj3 = createObj("王五",38,"男")

3）使用构造函数来创建对象

/*
语法：
function 构造函数名(){
    this.属性 = 值;
    this.方法 = function(){};
}
*/
​
/*
创建一个构造函数，专门用来创建可以区分出对象的
    构造函数就是一个普通的函数，创建方式和普通函数没有区别
    不同的是构造函数习惯首字母大写
构造函数和普通函数的区别就是调用方式的不同
    普通函数是直接调用，而构造函数需要使用new关键字来调用
构造函数的执行流程：
    1.立刻创建一个新的对象
    2.将新建的对象设置为函数中的this，在构造函数中可以使用this
    3.逐行执行函数中的代码
    4.将新建的对象作为返回值返回
使用同一个构造函数创建的对象，我们称为一类对象，也将一个构造函数称为一个类
    我们将通过一个构造函数创建的对象，称为是该类的示例
*/
function Person(name,age,gender){
    this.name = name;
    this.age = age;
    this.gender = gender;
    this.sayName = funtion(){
        alter(this.name);
    }
}
var per = new Person("张三",18,"男");
​
function Dog(name,age){
    this.name = name;
    this.age = age;
}
var dog = new Dog("旺财",3);
console.log(per); //Person类型对象
console.log(dog); //Dog类型对象

八、函数

1.函数简介

函数也是一个对象，函数中可以封装一些功能（代码），在需要时可以执行这些功能

封装到函数中的代码不会立即执行，需要调用函数时才执行其中代码

2.函数的创建方式

1）函数声明

/*
使用函数声明来创建一个函数
语法：function 函数名([参数1,参数2,.....]){
        代码...
}
调用函数语法：函数名()
*/
function fun(){
    console.log("我是函数声明创建的函数");
}
fun(); //我是函数声明创建的函数

2）函数表达式

console.log("我是函数声明创建的函数")/*
使用函数表达式来创建一个函数
var 函数名 = function([参数1,参数2,.....]){
        代码...
}
*/
var fun2 = function(){
    console.log("我是函数表达式创建的函数");
}
fun2(); //我是函数表达式创建的函数

3.函数的形参与实参

/*
可以在函数的()中来指定一个或多个形参
多个形参之间使用，隔开，声明形参就相当与在函数内部声明了对应的变量，但没有赋值
*/
function sum(a.b){
    console.log(a+b);
}
​
//在调用函数时，可以在()中指定实参
sum(1,2); //3
​
/*
调用函数时，解析器不会检查实参的数量
多余的实参不会被赋值
而如果实参的数量少于形参的数量，则没有对应实参的形参被赋值为undefined
*/
sum(1,2,3,4,5,6) //3
sum(1) //NaN

补充：实参可以是任意数据类型的数据

4.立即执行函数

函数定义后，立即执行，且只执行一次

(function(){
    console.log("立即执行函数")
})();
​
//带参数的立即执行函数
(function(a,b){
    console.log(a+b)
})(1,2);

5.枚举对象中的属性

for...in...语句

/*
语法 for(var 变量 in 对象){
        代码...
}
for...in...语句 对象中有几个属性，循环体就会执行几次
*/
var obj = {
    name:"张三",
    age:18,
    gender:"男",
    address:"牢房"
}
for (var o in obj){
    console.log(o) //依次输出对象中的属性名
    console.log(obj.o) // undefined,obj对象中没有o这个属性名
    console.log(obj[0]) //依次输出对应的对象名中的对象值
}

6.作用域

作用域指一个变量的作用的范围

1）全局作用域

—— 直接编写在script标签中的JS代码

—— 全局作用域在页面打开时创建，在页面关闭时销毁

—— 在全局作用域中有一个全局对象window（它代表的时一个浏览器的窗口，由浏览器创建我们可以直接使用）

—— 在全局作用域中：

创建的变量都会作为window对象的属性保存

创建的函数都会作为window对象的方法保存

—— 全局作用域中的变量在页面的任意部分都可以访问的到

2）函数作用域

—— 调用函数时创建函数作用域，函数执行完毕后，函数作用域消耗

—— 每调用依次函数就会创建一个新的函数作用域，它们之间是相互独立的

—— 在函数作用域中可以访问到全局作用域的变量

但在全局作用域中无法访问到函数作用域的变量

—— 当函数作用域操作一个变量时，它会先在自身作用域中寻找，如果有就直接用

如果没有则向上一级作用域中寻找，直到找到全局作用域

如果全局作用域中依然没有找到，则会报错

7.变量于函数的提升

1）变量提升

/*
变量的声明提前
    使用var关键字声明的变量，会在所有的代码执行前被声明(但是不会被赋值)
*/
console.log(a); //输出undefined
var a = 1;
​
console.log(a); //会报错
a = 1;

2）函数提升

/*
函数的声明提前
    使用函数声明形式创建的函数function 函数(){}，它会在所有的代码执行前就被创建
*/
fun(); //我是函数声明所创建的
fun2(); //报错，因为undefined不是一个函数
function fun(){
    console.log("我是函数声明所创建的");
}
var fun2 = function(){
    console.log("我是函数表达式创建的");
}

注意：在函数作用域也有变量声明提前的特性

即使用var关键字声明的变量，会在函数中所有执行的代码之前被声明

在函数中，如果不使用var声明的变量，则会成为全局变量

8.提升练习

------------------------------------
var a = 123;
function fun(){
    alter(a);
}
fun(); //123
------------------------------------
var a = 123;
function fun(){
    alter(a);
    var a = 456;
}
fun(); //undefined,在函数作用域中使用var声明了变量a
alter(a); //123，在函数作用域中使用了var声明变量a
------------------------------------
var a = 123;
function fun(){
    alter(a);
    a = 456;
}
fun(); //123,在函数作用域中没有使用var声明了变量a
alter(a); //456, 在函数作用域中没有使用var声明了变量a
------------------------------------
var a = 123;
function fun(a){
    alter(a);
    a = 456;
}
fun(); //undefined,实参数量小于形参
alter(a); //456
------------------------------------
var a = 123;
function fun(a){
    alter(a);
    a = 456;
}
fun(123); //123
alter(a); //123,因为在此函数作用域中已经存在变量a，所有不会找到全局作用域中的a
------------------------------------

9.this相关知识

解析器在调用函数每次都会向函数内部传递一个隐含的参数，

这个隐含的参数就是this，this指向一个对象，

这个对象就是我们称为函数执行的 上下文对象，

根据函数的调用方式不同，this会指向不同的对象

/*
this的情况：
    1.当以函数的形式调用时，this是window
    2.当以方法的形式调用时，谁调用方法this就是谁
    3.当以构造函数的形式调用时，this就是新创建的那个对象
    4.使用call()和apply()调用时，this是指定的那个对象
*/
function fun(){
    console.log(this);
}
var obj = {
    name:"张三",
    sayName:fun
};
fun(); //此时this为window
obj.sayName(); //此时this为obj

10.原型对象(prototype)

问题：

在构造函数中定义方法，那么每创建一个对象就会生成一个对应的相同的方法，从而浪费大量的内存空间

而将函数定义在全局作用域，则污染了全局作用域的命名空间，且不安全

/*
原型prototype
    我们所创建的每一个函数，解析器都会向函数中添加一个属性prototype
        这个属性对应着一个对象，这个对象就是我们所谓的原型对象
    如果函数作为普通函数调用prototype没有任何作用
    但当以构造函数的形式调用时，它所创建的对象中都会有一个隐含的属性(__proto__)来指向该构造函数的原型对象
*/
function Fun(){
    
}
var fun = new Fun();
var fun2 = new Fun();
console.log(fun.__proto__ == Fun.prototype) //true
console.log(fun2.__proto__ == Fun.prototype) //true
​
/*
原型对象就相当于一个公共区域，所有同一个类的实例都可以访问到这个原型对象，
    所以我们可以将对象中共有的内容，统一设置到原型对象中
当我们访问对象的一个属性或方法时，它会先在对象自身中寻找，如果有则直接使用，
    如果没有则会去原型对象中寻找，找到则也直接使用
以后我们创建构造函数时，可以将这些对象共有的属性和方法，统一添加到构造函数的原型对象中去，
    这样不用分别为每一个对象添加，也不会影响到全局作用域，就可以使每个对象拥有这些属性和方法了
*/
Fun.prototype.salary = 8000;
Fun.prototype.sayName = funtion(){
    console.log(this.name);
}

注意：

使用in检查对象中是否含有某个属性时，如果对象中没有但是原型中有，也会返回true

所以可以使用对象的hasOwnProperty（）来检查对象自身中是否含有该属性

11.toSting（）方法

当我们直接在页面中打印一个对象时，事实上是输出对象的toString（）方法的返回值

/*
如果我们希望在输出对象时不输出[object object]，可以为对象添加一个toString()方法
*/
function Fun(){
    
}
var fun = new Fun();
fun.toString = function(){
    console.log("我是一个快乐又积极的person");
}
console.log(fun); //我是一个快乐又积极的person

九、数组

1.数组简介

数组也是一个对象

它和我们普通对象功能类似，也是用来存储一些值的

不同的是普通对象使用字符串作为属性名，而数组使用数组作为索引来操作元素

数组中的元素可以是任意数据类型

2.数组的基本操作

/*
创建数组：
    1）利用构造函数来创建数组对象
    2）利用数组字面量来创建数组
*/
var arr = new Array();
var arr = [];
​
/*
向数组中添加元素
    语法: 数组[索引] = 值
读取数组中的元素
    语法 数组[索引]
    如果读取不存在的索引，它不会报错而是返回undefined
*/
arr[0] = 0;
arr[1] = 1;
console.log(arr[0]); // 0
console.log(arr[2]); //undefined
​
/*
可以使用length属性来获取数组的长度
    语法：数组.length
对于连续的数组，使用length可以获取到数组的长度
而对于非连续的数组，使用length会获取到数组的最大索引+1
*/
console.log(arr.length) // 2
arr[10] = 10
console.log(arr.length) //11
​
//向数组的最后一个位置添加元素
//语法：数组[数组.length] = 元素
arr[arr.length] = xxx

3.数组中的方法（常用）

var arr = [];
/*
push()
    该方法可以向数组的末尾添加一个或多个元素，并返回数组的新的长度
*/
arr.push(1);
var length = arr.push(2,3);
console.log(arr); // 1,2,3
console.log(length); //3
​
/*
pop()
    该方法可以删除数组的最后一个元素,并将被删除的元素作为返回值返回
*/
var result = arr.pop();
console.log(arr); // 1,2
console.log(result); // 3
​
/*
unshift()
    向数组开头添加一个或多个元素，并返回新的数组长度
    向前边插入元素以后，其他的元素索引会依次调整
*/
var length = arr.unshift(0);
console.log(arr); // 0,1,2
console.log(length); // 3
​
/*
shift()
    可以删除数组的第一个元素，并将被删除的元素作为返回值返回
*/
var result = arr.shift();
console.log(arr); // 1,2
console.log(result); // 0
​
/*
slice(start,end)
    可以用来从数组中提前指定元素
    该方法不会改变元素数组，而是将截取到的元素封装到一个新数组中返回
    参数：
        1.截取开始位置的索引（包含开始位置）
        2.截取结束位置的索引（不包含结束位置）
        当第二个参数省略不屑时，此时会截取从开始索引往后位置的所以元素
        索引可以传递一个负值，如果传递一个负值，则从后往前计算
            -1 倒数第一个
            -2 倒数第二个
*/
var arr = [1,2,3,4,5];
var newArr = arr.slice(0,2);
console.log(arr); // 1,2,3,4,5
console.log(newArr); // 1,2
​
/*
splice(start,much)
    可以用于删除数组中指定的元素
    使用splice()会影响到原数组，会将指定元素从原数组中删除，并将被删除元素作为返回值返回
    参数：
        1.表示开始位置的索引
        2.表示删除的数量
*/
var arr = [1,2,3];
var result = arr.splict(0,2);
console.log(arr); // 3
console.log(result); // 1,2
​
/*
concat()可以连接两个或多个数组，并将新的数组返回（该方法不会对原数组产生影响）
*/
var arr = [0];
var arr2 = [1];
var result = arr.concat(arr2);
console.log(result); // 0,1
​
/*
join()
    该方法可以将数组转换为一个字符串
    该方法不会对原数组产生影响，而是将转换后的字符串作为结果返回
    在join()中可以指定一个字符串作为参数，这个字符串将会成为数组中元素的连接符
    如果不指定连接符，则,默认为连接符
*/
var arr = [1,2,3];
result = arr.join("-");
console.log(result); // 1-2-3
result = arr.join();
console.log(result); // 1,2,3
​
/*
reverse()
    该方法用来翻转数组，会直接修改原数组
*/
var arr = [1,2,3];
arr.reverse();
console.log(arr); // 3,2,1
​
/*
sort()
    可以用来对数组中的元素进行排序
    会影响原数组，默认按照Unicode编码进行排序
    所以我们可以自己来指定排序规则
    我们可以在sotr()中添加一个回调函数，来指定排序顺序
        浏览器会分别使用数组中的元素作为实参去调用回调函数
        如果需要升序排列，则返回a-b
                降序排列，则返回b-a
*/
var arr = [5,4,1,3,2];
arr.sort(function(a,b){
    //return a-b;
    return b-a;
})
//console.log(arr); // 1,2,3,4,5
console.log(arr); // 5,4,3,2,1

4.数组中的循环遍历（forEach）

/*
forEach()方法需要一个函数作为参数
    像这种函数，由我们创建但是不由我们调用的，称为回调函数
    数组中由几个元素，函数就会执行几次，每次执行时，浏览器都会遍历到的元素，会以实参的形式传递进来，我们可以来定义形参读取这些内容
    而浏览器会在回调函数中传递三个参数：
        第一个参数：就是当前正在遍历的元素
        第二个参数：就是当前正在遍历元素的索引
        第三个参数：就是正在遍历的数组
*/
var arr = [1,2,3];
arr.forEach(function(value,index,obj){
    console.log(value); // 1,2,3
    console.log(index); // 0,1,2
    console.log(obj == arr); //true true true
})