字符串的常用方法
都是用来操作字符串的
所有的方法都不改变原始字符串
所有的操作都是以返回值的形式给结果
1. charAt()
解释一下名字
char: 字符, 表示一个字符
at: 在哪
作用: 根据索引找到对应的字符返回
语法:
字符串.charAt(索引)
返回值: 对应索引位置的字符
如果有对应索引, 那么得到的就是对应索引位置的字符
如果没有对应索引, 那么得到的是 空字符串
2. charCodeAt()
作用: 根据索引找到对应的字符, 返回字符的编码
语法:
字符串.charCodeAt(索引)
返回值: 对应索引位置的字符编码 UTF-8 编码
3. substr()
作用: 从字符串里面提取出一些内容
语法:
字符串.substr(开始的索引, 多少个)
第二个参数不写, 默认是按照到字符串末尾计算
返回值: 一个新的字符串
从原先字符串里面提取出来的内容
4. substring()
作用: 从字符串里面提取出一些内容
语法:
字符串.substring(开始索引, 结束索引) - 包前不包后
第二个参数不写, 默认到末尾
返回值: 一个新的字符串
从原先字符串里面提取出来的内容
5. toLowerCase()
作用: 把字符串里面所有的大写字母转换成小写字母
语法:
字符串.toLowerCase()
返回值: 就是转换好的字符串
6. toUpperCase()
作用: 把字符串里面所有的小写字母转换成大写字母
语法:
字符串.toUpperCase()
返回值: 就是转换好的字符串
7. split()
作用: 按照你的需求, 切割字符串
语法:
字符串.split(‘你要切割的字符’)
参数你写什么就按照什么给你切割
参数你要是写一个字符串里面没有的字符, 那么给你切割出一个整个的
参数要是不写, 也是切割一个整个的
参数你要是写一个 空字符串(’’), 会一位一位给你切割
返回值: 是一个 数组
按照你的规则切割好每一部分, 都放到数组里面
接下来的方法, 只是和数组方法重名, 但是是两个数据的方法
8. slice()
作用: 从字符串里面提取一部分数据
语法:
字符串.slice(开始索引, 结束索引) - 包前不包后
字符串.slice(开始索引, 负整数)
当你写负整数的时候, 表示 字符串.length + 负整数
返回值: 一个字符串
从原始字符串里面提取出来的一部分
9. concat()
作用: 拼接字符串
语法:
字符串.concat(要拼接的字符串1, 要拼接的字符串2, …)
返回值:
一个拼接好的字符串
作用和 加号(+) 是一模一样的
10. indexOf()
作用: 通过字符, 查找到对应的索引返回
语法:
字符串.indexOf(你要查找的字符)
字符串.indexOf(你要查找的字符, 从那个索引开始查找)
返回值: 一个数字
如果有这个字符, 那么就返回找到的第一个字符位置的索引
如果没有这个字符, 那么就返回 -1
11. lastIndexOf()
作用: 通过字符, 查找到对应的索引返回, 从后往前查找
语法:
字符串.lastIndexOf(你要查找的字符)
字符串.lastIndexOf(你要查找的字符, 开始的索引)
返回值: 一个数字
如果有这个字符, 那么就返回找到的第一个字符位置的索引
如果没有这个字符, 那么就返回 -1
// 1. charAt()
// var str = ‘hello world’
// var res = str.charAt(8)
// console.log(res)
// 2. charCodeAt()
// var str = ‘你好 世界’
// // res 获取的是 你 这个汉字的编码
// var res = str.charCodeAt(1)
// console.log(res)
// 3. substr()
// var str = ‘hello world’
// // 从索引 1 开始, 向后数 7 个, 提取出来
// var res = str.substr(1, 7)
// console.log(res)
// 4. substring()
// var str2 = ‘hello world’
// // 从索引 1 开始, 到索引 7, 不包含索引 7
// var res2 = str2.substring(1, 7)
// console.log(res2)
// 5. toLowerCase()
// var str = ‘ABCDEFGHIJKLMN’
// var res = str.toLowerCase()
// console.log(res)
// 6. toUpperCase()
// var str2 = ‘opqrstuvwxyz’
// var res2 = str2.toUpperCase()
// console.log(res2)
// 7. split()
// var str = ‘2020-05-20’
// // 用 - 把字符串分开, 每一段都作为一个数据放在数组里面
// var res = str.split(’-’)
// console.log(res)
// 8. slice()
// var str = ‘abcdefghijklmn’
// 提取 str 字符串中索引 1 到索引 10 的字符, 不包含索引 10
// var res = str.slice(1, 10)
// 你写 -3 等价于 str.length + -3 === 11
// var res = str.slice(1, -3)
// var res = str.slice(1, 11)
// console.log(res)
// 9. concat()
// var str = ‘hello world’
// var res = str.concat(’ 你好 世界’)
// console.log(res)
// 10. indexOf()
// var str = ‘hello world’
// // 当你找一个多个字母的字符的时候, 会找到匹配的第一个字母的位置返回
// var res = str.indexOf(‘world’)
// console.log(res)
// 11. lastIndexOf()
// var str = ‘hello world’
// var res = str.lastIndexOf(‘l’)
// console.log(res)
操作数字的属性和方法
对数字进行操作
JS 里面有一个内置对象叫做 Math
他里面保存了很多操作数字的方法和属性
1. Math.random()
作用: 给你生成一个随机数 0 ~ 1, 包含 0 不包含 1
语法: Math.random()
返回值: 就是一个随机数字, 0 ~ 1 之间, 包含 0 不包含 1
2. Math.round()
作用: 对一个数字进行 四舍五入 取整
语法: Math.round(你要取整的数字)
返回值: 就是取整好的数字
3. Math.ceil()
作用: 对一个数字进行 向上 取整
语法: Math.ceil(你要取整的数字)
返回值: 就是取整好的数字
4. Math.floor()
作用: 对一个数字进行 向下 取整
语法: Math.floor(你要取整的数字)
返回值: 就是取整好的数字
5. Math.abs()
作用: 对一个数字取 绝对值
语法: Math.abs(你要取绝对值的数字)
返回值: 就是取好绝对值的数字
6. Math.pow()
作用: 对一个数字进行 幂 运算
语法: Math.pow(一个数字, 的几次方)
返回值: 一个数字取幂后的结果
7. Math.sqrt()
作用: 对一个数字进行开算术平方根, 开二次算术平方根(只能开二次算术平方根)
语法: Math.sqrt(你要开平方的数字)
返回值: 一个开好平方根的数字
8. Math.max()
作用: 选出若干个数字里面最大的那一个
语法: Math.max(数字1, 数字2, 数字3, …)
返回值: 若干个实参中最大的那个数字
9. Math.min()
作用: 选出若干个数字里面最小的那一个
语法: Math.min(数字1, 数字2, 数字3, …)
返回值: 若干个实参中最小的那个数字
10. Math.PI
注意: 是一个属性, 不是方法, 使用不需要括号
作用: 给你一个近似于 Π(pai) 的值
// 1. random()
// var n1 = Math.random()
// console.log(n1)
// 2. round()
// var n2 = Math.round(10.49) // 10
// console.log(n2)
// 3. ceil()
// 向上取整就是不管小数点是几都进位
// var n3 = Math.ceil(-10.1) // -11 -9 -10
// console.log(n3)
// 4. floor()
// var n4 = Math.floor(10.999)
// console.log(n4)
// 5. abs()
// var n5 = Math.abs(-20) // 20
// console.log(n5)
// 6. pow()
// var n6 = Math.pow(2, 10) // 1024
// console.log(n6)
// 7. sqrt()
// 求 4 的算数平方根
// var n7 = Math.sqrt(4)
// console.log(n7)
// 8. max()
// var n8 = Math.max(10, 20, 50, -100, -30, 99, 72)
// console.log(n8)
9. min()
// var n9 = Math.min(10, 20, 50, -100, -30, 99, 72)
// console.log(n9)
// 10. PI
// var n10 = Math.PI
// console.log(n10)
范围内的随机整数
10 ~ 20 的随机整数
1. 0 ~ 10 的随机整数
整数, Math.round() Math.ceil() Math.floor()
因为我们的 Math.random() 是 0 ~ 1 之间的随机小数
直接使用 Math.random() * 10
取值范围: 0 ~ 1
0 * 10 === 0
0.999 * 10 === 9.99
取整: Math.round()
0 ~ 0.499 得到 0
0.5 ~ 1.499 得到 1
8.5 ~ 9.499 得到 9
9.5 ~ 10 得到 10
取整: Math.floor()
0 ~ 0.999 得到 0
1 ~ 1.999 得到 1
8 ~ 8.999 得到 8
9 ~ 9.999 得到 9
换一个想法, 得到小数的时候, 不要 0 ~ 10 之间的
我取得 0 ~ 11 之间的小数
取整: Math.floor()
0 ~ 0.999 得到 0
1 ~ 1.999 得到 1
9 ~ 9.999 得到 9
10 ~ 10.999 得到 10
2. 两个数字范围之间的随机整数
0 ~ 10 的随机整数 + 10 得到的结果取值范围是多少 10 ~ 20 差值 10
0 ~ 10 的随机整数 + 20 得到的结果取值范围是多少 20 ~ 30 差值 10
0 ~ 30 的随机整数 + 10 得到的结果取值范围是多少 10 ~ 40 差值 30
两个整数的之间的随机整数
0 ~ 两个数字差值之间的随机整数 + 相对比较小的那个数字
求 x ~ y 的随机整数, 假设 x 小, y 大
0 ~ (y - x) 之间的随机整数 + x
取 0 ~ 10 之间的随机整数 Math.random() * (10 + 1)
取 0 ~ 20 之间的随机整数 Math.random() * (20 + 1)
取 0 ~ 30 之间的随机整数 Math.random() * (30 + 1)
取 0 ~ (y - x) 之间的随机整数 Math.random() * (y - x + 1)
把这个功能封装成一个函数
1. 准备一个函数, 接收两个参数
2. 计算出两个数字之间的随机数
3. 把这个随机数字返回
// 封装函数
// 1. 准备一个函数, 接收两个参数
function fn(x, y) {
// 2. 计算出两个数字之间的随机数
// 2-1. 先要确定 x 和 y 相对大的和相对小的数字
var max = Math.max(x, y)
var min = Math.min(x, y)
// 2-2. 利用这个大数字和小数字取出随机整数
var n = Math.floor(Math.random() * (max - min + 1) + min)
// 3. 把这个随机数字返回
return n
}
// 使用的时候
// res 得到的就是 10 ~ 20 之间的一个随机整数
var res = fn(30, 20)
console.log(res)
// x ~ y 之间的随机整数
// var x = 10
// var y = 20
// // 1. 计算出差值 + 1
// var n1 = y - x + 1
// // 2. 计算出 0 ~ cha 的随机整数 + 相对小的那个数字
// var n2 = Math.random() * n1 + x
// // 3. 向下取整
// var n3 = Math.floor(n2)
// console.log(n3)
// 0 ~ x 的随机整数
// 取得一个随机小数
// var n1 = Math.random()
// 把这个数字 * 11
// var n2 = n1 * 11
// 使用 floor 方法取整
// var n3 = Math.floor(n2)
// var n = Math.floor(Math.random() * (10 + 1))
// console.log(n)
转换进制
1. toString()
作用: 把一个十进制数字转换成其他进制的数字
语法: 你要转换的数字.toString(转换成几进制)
参数的取值范围 2 ~ 36
返回值: 是一个字符串, 转换好进制的结果
2. parseInt()
作用: 把其他进制的数字转换成十进制的数字
语法: parseInt(你要转换的数字, 你的数字是几进制)
返回值: 是一个数字, 就是转换好的十进制数字
// 1. toString()
// var n1 = 35
// // 把 n1 这个数字转换成 三十六进制, 以字符串的形式给你
// var res = n1.toString(36) // ‘z’
// console.log(res)
// 2. parseInt()
var n1 = ‘z’
// 把 n1 的值当作一个 三十六进制 的数字, 转换成 十进制 数字
var res = parseInt(‘z’, 36) // 35
console.log(res)
保留小数的方法
1. toFixed()
作用: 给一个数字保留指定位的小数
语法: 数字.toFixed(你要保留几位小数)
返回值: 一个字符串, 就是保留好小数的数字
如果这个数字本身就没有那么多小数, 那么用 0 补齐
说明
你保留 n 位小数, 看 n + 1 位是几就进行四舍五入保留
// 1. toFixed()
var n1 = 10.123456789
var res = n1.toFixed(4)
console.log(res)
创建时间对象
时间对象是一个 复杂数据类型
1. 内置构造函数创建时间对象
语法: var time = new Date()
返回值: 就是你电脑上的当前时间 (包含时区)
通过传递不同的参数获取到一个指定时间节点的时间对象
1. 传递数字
至少传递两个数字(传递一个数字得到的是格林威治时间)
第一个数字: 表示年
第二个数字: 表示月(0 表示 1 月, 11 表示 12 月)
第三个数字: 表示日(1 表示 1 号, 31 表示 31 号)
第四个数字: 表示小时(0 表示 0 点, 23 表示 23 点)
第五个数字: 表示分钟(0 表示 0 分, 59 表示 59 分)
第六个数字: 表示秒钟(0 表示 0 秒, 59 表示 59 秒)
第七个数字: 表示毫秒(0 表示 0 毫秒, 999 表示 999 毫秒)
2. 传递字符串
一个字符串表示所有内容
‘YYYY-MM-DD HH:mm:ss’
只设置年月日, 可以一起设置
年月日之间可以用 - 连接, 也可以用 / 连接
注意: 传递字符串的时候
1 就表示 1 月, 12 表示 12 月
// 1. 创建时间对象
// var time = new Date()
// console.log(time)
// 创建指定时间节点的时间对象
// 1. 传递数字
// 2018 年 1 月, 剩下的时间都按照默认值走
// var time = new Date(2018, 0)
// console.log(time)
// 2018 年 1 月 2 号, 剩下的时间都按照默认值走
// var time = new Date(2018, 0, 2)
// console.log(time)
// 2018 年 1 月 2 号 15 点, 剩下的时间都按照默认值走
// var time = new Date(2018, 0, 2, 15)
// console.log(time)
// 2018 年 1 月 2 号 15 点 55 分, 剩下的时间都按照默认值走
// var time = new Date(2018, 0, 2, 15, 55)
// console.log(time)
// 2018 年 1 月 2 号 15 点 55 分 55 秒, 剩下的时间都按照默认值走
// var time = new Date(2018, 0, 2, 15, 55, 55)
// console.log(time)
// 2018 年 1 月 2 号 15 点 55 分 55 秒 666 毫秒, 剩下的时间都按照默认值走
// var time = new Date(2100, 0, 2, 15, 55, 55, 666)
// console.log(time)
// 2. 传递字符串
// var time = new Date(‘2018-1-22’)
// console.log(time)
// var time = new Date(‘2018/1/22’)
// console.log(time)
// var time = new Date(‘2018/1/22 15:22:32’)
// console.log(time)
获取时间对象内数据的方法
就是从时间对象里面获取到某些信息
1. getFullYear()
作用: 获取时间对象里面的 年份信息
语法: 时间对象.getFullYear()
返回值: 就是该时间对象里面的 年份信息, 是一个 number 类型
2. getMonth()
作用: 获取时间对象里面的 月份信息(0 表示 1 月, 11 表示 12 月)
语法: 时间对象.getMonth()
返回值: 就是该时间对象里面的 月份信息, 是一个 number 类型
3. getDate()
作用: 获取时间对象里面的 日期信息
语法: 时间对象.getDate()
返回值: 就是该时间对象里面的 日期信息, 是一个 number 类型
4. getHours()
作用: 获取时间对象里面的 小时信息
语法: 时间对象.getHours()
返回值: 就是该时间对象里面的 小时信息, 是一个 number 类型
5. getMinutes()
作用: 获取时间对象里面的 分钟信息
语法: 时间对象.getMinutes()
返回值: 就是该时间对象里面的 分钟信息, 是一个 number 类型
6. getSeconds()
作用: 获取时间对象里面的 秒钟信息
语法: 时间对象.getSeconds()
返回值: 就是该时间对象里面的 秒钟信息, 是一个 number 类型
7. getDay()
作用: 获取时间对象里面的 周几信息(1 表示周一, 0 表示周日)
语法: 时间对象.getDay()
返回值: 就是该时间对象里面的 周几信息, 是一个 number 类型
8. getTime()
作用: 获取时间对象里面的 时间戳
语法: 时间对象.getTime()
返回值: 就是该时间对象里面的 时间戳, 是一个 number 类型
时间戳:
我们计算机有一个计算机元年时间
叫做格林威治时间(1970 年 1 月 1 号, 0 点 0 分 0 秒)
时间戳, 就是从 格林威治时间 到 指定时间的 总毫秒数
var time = new Date()
console.log(time)
// 1. 获取年
var year = time.getFullYear()
console.log(year)
// 2. 获取月
var month = time.getMonth()
console.log(month)
// 3. 获取日
var date = time.getDate()
console.log(date)
// 4. 获取时
var hours = time.getHours()
console.log(hours)
// 5. 获取分
var minutes = time.getMinutes()
console.log(minutes)
// 6. 获取秒
var seconds = time.getSeconds()
console.log(seconds)
// 7. 获取周几
var week = time.getDay()
console.log(week)
// 8. 获取时间戳
var ms = time.getTime()
console.log(ms)
设置时间对象的指定内容
我单独只设置时间对象里面的某一个信息
1. setFullYear()
作用: 设置时间对象的年份信息
语法: 时间对象.setFullYear(你要设置的年份)
2. setMonth()
作用: 设置时间对象的月份信息(0 表示 1 月, 11 表示 12 月)
语法: 时间对象.setMonth(你要设置的月份)
3. setDate()
作用: 设置时间对象的日期信息
语法: 时间对象.setDate(你要设置的日期)
4. setHours()
作用: 设置时间对象的小时信息
语法: 时间对象.setHours(你要设置的小时)
5. setMinutes()
作用: 设置时间对象的分钟信息
语法: 时间对象.setMinutes(你要设置的分钟)
6. setSeconds()
作用: 设置时间对象的秒钟信息
语法: 时间对象.setSeconds(你要设置的秒钟)
7. setTime()
作用: 通过时间戳直接设置一个时间对象
语法: 时间对象.setTime(时间戳)
var time = new Date()
// 1. 设置年
// time.setFullYear(2018)
// // 2. 设置月
// time.setMonth(0)
// // 3. 设置日期
// time.setDate(10)
// // 4. 设置小时
// time.setHours(12)
// // 5. 设置分钟
// time.setMinutes(12)
// // 6. 设置秒钟
// time.setSeconds(12)
// console.log(time)
// 7. 设置时间戳
time.setTime(1515557532561)
// 1515557532561
console.log(time)