【JavaScript】Day4——对象、简单与复杂数据类型

对象

▍ 对象是一组无序的属性方法的集合

创建对象的三种方式

  1. 利用字面量创建对象
  2. 利用new Object创建对象
  3. 利用构造函数创建对象
// 字面量
var obj = {
	name: 'loli',				// 属性:值
	age: 12,
	sayHi: function() {			// 方法:匿名函数
		console.log('rua!!!')
	}
}

// new一个对象
var obj = new Object();
obj.name = 'loli';				// 利用"="
obj.age = 12;
obj.sayHi = function() {
	console.log('rua!!!')
}

// 构造函数
var Loli(name, age) {			// Loli就是一个类(class)
	this.name = name;
	this.age = age;
	this.sayHi = function() {
		console.log('rua!!!')
	}
}
var obj = new Loli('loli', 12);


// 对象的使用是完全相同的:
alert(obj.age);			// 调用属性
alert(obj['age']);		// 这两种调用属性的格式都可以
obj.sayHi();			// 调用方法

// 遍历对象
for(var k in obj) {		// 输出的是属性名(包括方法名,但我们不需要)
	console.log(k);		
}
for(var k in obj) {		// 输出的是属性值(方法的值就是整个匿名函数,我们更不需要)
	console.log(obj[k])
}

 
内置对象

JavaScript中的对象分为三种:自定义对象内置对象浏览器对象

// Math
Math.PI				// 返回3.141592653589793
Math.max(3, 5)		// 返回5
Math.max(3, 5, 9) 	// 返回9;参数可以任意多个
Math.max(2, '9')	// 返回9
Math.max(2, 'Loli')	// 返回NaN
Math.max()			// 无参数返回的是-Infinity
Math.max.apply(null, arr)		//求数组的最大值

Math.abs(-233)		// 绝对值
Math.abs('-233')	// 也返回233;对数字字符串进行了隐式转换

Math.floor(2.33)	// 2, 向下取整
Math.ceil(2.33)		// 3, 向上取整
Math.round(2.5)		// 3, 四舍五入
Math.round(-2.5)	// -2, 一个小坑!四舍五入的机制在.5时向趋向较大数

Math.random()		// 返回随机浮点数,范围[0, 1)




// Date
var date = new Date();					// 没有参数,返回系统当前时间
var date = new Date(2022, 06, 21);		// 传入数字(数字型有点小坑,传入6,认为是7月;月份的数字型是从0~11)
var date = new Date('2022-06-21');		// 传入字符串(6就是6月)

date.getFullYear()		// 返回年
date.getMonth() + 1		// 返回月(小坑,数字型的月份是0~11,需要修正一下)
date.getDate()			// 返回日(一个月中的第几天,不是一年中的第几天)
date.getDay()			// 返回星期(小坑,1~6对应周一到周六没有问题,但周日是0——西方的习惯)

date.getHours()			// 返回 时
date.getMinutes()		// 返回 分
date.getSeconds()		// 返回 秒

date.valueOf()			// 返回毫秒数
date.getTime()			// ↑
+new Date()				// ↑
Date.now()				// ↑
// 关于毫秒数,多说几句: 因为时间永不停歇,因此每次刷新都会获得一个不同的毫秒数,也称为【时间戳】
// 毫秒数是此时到1970年1月1日的时间间隔,为什么是1970年呢?因为unix认为1970年为时间元年
// 那为什么偏偏是1970呢?那是因为在多年前的计算机都是32位,Integer.MAX_VALUE表示秒数,最多68年就会回归。
// 当时的人们权衡了一下,从1970年过78年后的2038年,64位计算机就该问世了,而64位计算机表示秒数,年数直至地球毁灭,也就彻底解决了时间回归的问题




// Array
var arr = new Array(2);			// 创建一个长度为2的数组,里面有两个空元素
var arr = new Array(2, 3);		// 创建了[2, 3]

Array.isArray(arr)				// 检测是否是数组
arr instanceof Array			// 检测是否是数组

arr.push('loli')				// 在数组末尾添加元素;可添加多个元素;返回值是新数组的长度
arr.unshift('loli')				// 在数组开头添加元素;可添加多个元素;返回值是新数组的长度
arr.pop()						// 删除数组的最后一个元素;返回的pop出的那个元素
arr.shift()						// 删除数组的开头第一个元素;返回是shift出的那个元素

arr.reverse()					// 数组翻转;改变原数组;返回新数组
arr.sort()						// 数组排序;改变原数组;返回新数组
// 注意:这个sort()方法有点坑,比如 [1, 3, 4, 12] 排序后为 [1, 12, 3, 4] ———— 它本质是按照字符串的排序方式进行排序
// 解决方案:sort内传入compareFunction方法作为排序依据
arr.sort(function(a, b) {return a - b});	// 升序
arr.sort(function(a, b) {return b - a});	// 降序

arr.indexOf('Loli')				// 返回第一个该元素的索引号;若找不到该元素则返回-1(有第二个参数指定查找开始位置)
arr.lastIndexOf('Loli')			// 返回第一个该元素的索引号(从后面开始找);若找不到该元素则返回-1

arr.toString()					// 数组转化为字符串(默认加逗号分隔)
arr.join('-')					// 数组转化为字符串(指定分隔符)
arr.join()						// 默认的分隔符是逗号

arr3 = arr1.concat(arr2)		// 数组连接	
	
	
// slice(start, [end]) 数组截取(返回的是截取下的子数组;原数组未改变)
newArr = arr.slice(1, 3)		// 截取出从1到3(不包括3)
newArr = arr.slice(1)			// 截取出从1到最后并返回


// splice(index, num, [item1...] (直接对原数组进行操作;可以实现删除,插入,替换)
// 弄清楚参数的逻辑,就很好理解不用死记:从下标index开始,删除num个元素,追加上item1、item2...
arr.splice(1, 2)						// 不指定追加元素,直接删除		
arr.splice(1, 0, 'loli')				// 删除元素数量设置为0,则实现插入效果
arr.splice(1, 2, 'loli', 'suki')		// 删除元素的数量等于追加元素的数量,实现替换效果

// 补充:splice的返回值是所删除的元素
// 再强调一次:slice没有改变原数组,只是截下来子数组;splice直接操作原数组




// 字符串
// 和Java几乎一样,再快速看一眼熟悉一下
// str = 'loli suki!!!';
str.indexOf('i')
str.indexOf('i', 5)
str.lastIndexOf('i')
str.charAt(3)
str.charCodeAt(3)
str[3]

str1.concat(str2)

str.substr(start, len)
str.slice(start, end)
str.substring(start, end)	// 特点是不接受负值索引

str.replace('a', 'b')		// 只替换第一个

str.split()					// 根据传入的分隔符,转化为数组

str.toUpperCase()
str.toLowerCase()

// 一些理解:
// var str = 'loli'; 很明显str是个简单数据类型,但为什么可以使用str.length属性,以及str.split等方法呢?
// 其实,JavaScript提供特殊的三种引用类型:String, Number, Boolean,也称为基本包装类型
// 一个值本身是不可能有属性和方法,但包装成复杂数据类型后,便获得属性和方法了

简单数据类型复杂数据类型

与Java类比一下:

简单数据类型就是基本数据类型

复杂数据类型就是引用

在传参时,简单数据类型就是传值,复杂数据类型就是传址

其实官话是这么说,最好还是这样理解传值和传址,不要记字眼

简单数据类型传参时,传递的是值本身,而实参和形参因为作用域的不同(不是在同一块栈上),因此它们是相互独立

复杂数据类型传参时,传递是位于堆上的对象的存取方法,它们虽然也不在同一块栈上,却指向堆上的同一对象

因此,从效果上来看,简单数据类型传参,其影响不会出去该方法(函数),而复杂数据类型传参将效果带出了方法(函数)

 
☀ Loli & JS

♫ Saikou

猜你喜欢

转载自blog.csdn.net/m0_46202073/article/details/106453115