JavaScript07

1.对象

(1)检测属性是否存在

对象.属性名 === undefined true -> 不存在 false -> 存在
对象.hasOwnProperty(‘属性名’) true -> 存在 false -> 不存在
‘属性名’ in 对象 true -> 存在 false -> 不存在

//检测属性是否存在
//true -> 不存在   false -> 存在
//console.log( emp.sex === undefined );
//true -> 存在   false -> 不存在
//console.log( emp.hasOwnProperty('phone') );
//true -> 存在   false -> 不存在
//console.log( 'ename' in emp );

练习：创建一个商品对象，包含商品的编号、标题、价格属性；如果颜色属性不存在，则添加该属性；如果价格属性存在，则打八折，最后打印对象。

var laptop = {
  lid: 3,
  title: '小米Air',
  price: 4200
};
//如果不存在
if(laptop.color === undefined){
  laptop.color = '白色';
}
//如果存在
if( laptop.hasOwnProperty('price') ){
  //打八折
  laptop.price *= 0.8;
}
console.log(laptop);

(2)对象中的方法

方法对应的是一个函数

//方法
function fn(){
  console.log(this.name+'正在养兔子');
}
var person = {
  //成员属性
  name: '涛桑', 
  sex: '男',
  //成员方法
  play: function(){
	//this指代调用当前方法的对象
    console.log(this.name+'正在玩单杠');
  },
  yang: fn
};
//console.log(person);
//调用方法
//person.play();
//person.yang();

练习：创建一个圆的对象，包含属性有半径和圆周率，添加计算周长和计算面积的两个方法，最后调用者两个方法

var circle = {
  r: 5,
  pi: 3.14,
  len: function(){
    return 2 * this.pi * this.r;
  },
  area: function(){
    return this.pi * this.r * this.r;
  }
};
//console.log( circle.len() );
//console.log( circle.area() );

练习：创建一个计算器对象，包含计算任意两个数字相加，计算任意两个数字相减的方法；调用两个方法。

var calc = {
  jia: function(a,b){
    return a + b;
  },
  jian: function(a,b){
    return a - b;
  }
};
console.log( calc.jia(2,3) );
console.log( calc.jian(10,3) );

2.数据的存储
(1)原始类型存储
直接存储在栈内存中

(2)引用类型存储

将数据存储在堆内存中，同时会自动生成一个地址，然后把这个地址保存到栈内存(变量)中

引用类型数据占用内存空间比较大，如果要销毁，没有任何的地址所指向，就会自动销毁。直接赋值为null即可销毁

3.数组

就是一组数据的集合，每个数据称为元素

(1)数组字面量

[ 元素1, 元素2, … ]

//字面量创建数组
var emps = ['tao','dong','hua',10,true];
//console.log(emps);

练习：创建数组，包含有一组商品的名称

var laptop = ['小米Air','Apple Air','外星人'];
​    创建数组，包含有一组成绩

练习: 创建数组，包含有一组成绩

var score = [80,97,63,78];
//console.log(score);

(2)元素的访问

数组[下标]
下标从0开始的整数，如果下标不存在返回undefined

//下标：自动为每个元素添加的编号，从0开始
//console.log( laptop[4] );
laptop[2] = 'ThinkPad';
laptop[3] = '戴尔';
laptop[5] = '华为';
//console.log(laptop)

练习：创建数组，保存一组汽车的品牌名称，修改其中的元素，在末尾添加若干元素，打印数组。

(3)数组的长度
数组.length 获取数组元素的个数
数组[ 数组.length ] = 值; 可以在数组的末尾添加元素

//练习：创建数组，保存一组汽车的品牌名称，修改其中的元素，
//在末尾添加若干元素，打印数组。
var car = ['长城','五菱宏光','比亚迪','蔚来'];
car[1] = '特斯拉';
car[3] = '劳斯莱斯';
//使用当前数组长度作为下标
car[car.length] = '吉利';
car[car.length] = '丰田';
car[car.length] = '本田';

练习：创建一个空数组，使用数组的长度属性不断添加元素。

//练习：创建一个空数组，使用数组的长度属性不断添加元素。
var arr = [];
arr[arr.length] = 'a';
arr[arr.length] = 'b';
arr[arr.length] = 'c';
console.log(arr);

(4)内置构造函数

new Array(元素1,元素2…)

//内置构造函数
var arr = new Array('a','b','c');

new Array(3) 创建数组，初始化数组长度为3，可以添加更多个元素

//初始化3个元素
var course = new Array(3);
course[0] = 'mysql';
course[1] = 'js';
course[2] = 'nodejs';
course[3] = 'ajax';
//console.log(course);

练习：创建数组，包含有多个国家

//练习：创建数组，包含有多个国家
var country = new Array('日本','印度','瓦坎达');
//console.log(country);

​ 创建数组，初始化长度为5，添加篮球场上的5个位置。(大前锋 小前锋 中锋 控球后卫 得分后卫)

var ball = new Array(5);
ball[0] = '大前锋';
ball[1] = '小前锋';
ball[2] = '中锋';
ball[3] = '控球后卫';
ball[4] = '得分后卫';
console.log(ball);

​

(5)数组的分类

索引数组：以0及以上整数作为下标 >=0

关联数组：以字符串作为下标，需要单独的添加元素

//索引数组：0及以上的整数作为下标
//关联数组：字符串作为下标
var person = [];
person['name'] = 'tao';
person['sex'] = '男';
person.age = 48;
//console.log(person);

//练习：创建数组，包含有一组商品，每个商品包含的属性编号、标题、价格；
var laptop = [
  {lid: 1,title: '小米Air',price: 4199},
  {lid: 2,title: 'thinkpad',price: 3799},
  {lid: 3,title: '联想小新',price: 5399}
];
//console.log(laptop);
//
//console.log( laptop[1].title );
//console.log( laptop[2].price );
//练习：创建一个学生对象，包含属性有学号，姓名，性别；选修的课程（可以选多个）
var student = {
  id: 1,
  name: '涛哥',
  sex: '男',
  course: ['体育','养殖','机械']
};
//console.log(student);
console.log( student.course[0] );

(6)数组的遍历

for-infor(var k in 数组){ k 代表下标 数组[k] 下标对应的元素}
循环for(var i = 0;i < 数组.length; i++){ i 代表下标 数组[i] 下标对应的元素}

var arr = ['tao','dong','tom','king'];
//遍历数组
//for-in
/*
for(var k in arr){
  //k 代表下标
  //arr[k]  元素
  console.log(k, arr[k]);
}

练习：创建数组，包含有一组成绩，将所有成绩在60分以下加10分；打印数组

//练习：创建数组，包含有一组成绩，将所有成绩在60分以下加10分；打印数组
var score = [87,91,55,63,49];
//遍历数组，得到每一个成绩
for(var k in score){
  //console.log(k,score[k]);
  //如果成绩在60以下
  if(score[k] < 60){
    //原来基础之上加10分
	score[k] += 10;
  }
}
console.log(score);

练习：创建数组，包含所有学生的成绩，遍历数组，计算出总分和平均分。

//练习：创建数组，包含所有学生的成绩，遍历数组，计算出总分和平均分。
var score = [87,91,55,63,49];
for(var i = 0,sum = 0;i < score.length;i++){
  //console.log(i,score[i]);
  //求和
  sum += score[i];
}
console.log(sum,sum/score.length);
*/
//练习：创建数组，保存一组数字，遍历数组，获取最大值
var score = [87,91,55,63,49];
//声明变量用于保存最大值,初始化第一个元素作为最大值
for(var i = 0,max = score[0];i < score.length;i++){
  //score[i]  代码每个数字
  //用max和每个数字进行比较，如果小于任意一个数字，则把该数字放入到max
  if(max < score[i]){
    max = score[i];
  }
}
//循环结束后，max找到了最大值
console.log(max);

(7)API

API：应用程序编程接口，JS下指提供好的函数或者方法

toString() 将数组转为字符串

join( str ) 将数组转为字符串，可以设置字符串之间的分割符

var arr = ['a','b','c'];
//转为字符串
console.log( arr.toString() );
console.log( arr.join('/') );

//var num = 5;
//console.log( num.toString() );
//如何区分两个方法(API)是不是同一个
//查看调用这个方法的对象，是不是相同的数据类型

(2)练习

创建数组，遍历数组，翻转数组中的元素；

[‘a’,‘b’,‘c’,‘d’] -> [‘d’,‘c’,‘b’,‘a’]

//1.创建数组，遍历数组，翻转数组中的元素
var arr = ['a','b','c','d'];
//把倒着的元素放入到一个新数组
var arr2 = [];
//遍历数组
for(var i = 0;i < arr.length;i++){
  //0  4  3
  //1  4  2
  //2  4  1
  //3  4  0
  //倒着元素的下标 = 数组长度 - i - 1
  //console.log(arr.length - i - 1);
  //把倒着找到的元素放入到新数组arr2
  arr2[i] = arr[arr.length - i - 1];
}
console.log(arr2);

创建数组包含一组数字，遍历数组，将数字进行从小到大排序(冒泡排序)

[78,6,45,23] [6,23,45,78]

//2.创建数组包含一组数字，遍历数组，将数字进行从小到大排序(冒泡排序)
var arr = [23,9,78,6,45];
//外层循环：控制循环的轮数(比元素的个数少1)
for(var i = 0;i < arr.length-1;i++){
//0  5  4
//1  5  3
//2  5  2
//3  5  1
//内层循环：控制每一轮比较的次数
//循环条件 = 数组长度 - i - 1
for(var j = 0;j < arr.length - i - 1;j++){
 //j 代表当前的数字的下标
 //j+1  代表下一个数字的下标
 //如果当前的数字大于下一个数字，则位置交换
 if(arr[j] > arr[j+1]){
   var c = arr[j];
   arr[j] = arr[j+1];
   arr[j+1] = c;
 }
}
}
console.log(arr);