JavaScript内置对象_封装函数,要求随机一个2-5之间的整数n,每隔n秒打印一次当前时间,格式案例:202

JavaScript 包含：ECMAscript、 DOM 、BOM

ECMAscript 包含：变量、数据、运算符、条件分支语句、循环语句、函数、数组、 对象……

JavaScript 的对象包含三种：自定义对象 内置对象 浏览器对象

ECMAscript 的对象：自定义对象 内置对象

内置对象

内置对象是指JS语言自带的一些对象，这些对象供开发者使用，并提供了一些常用的或是最基本而必要的功能（属性和方法）

内置对象最大的优点是帮助我们快速开发

使用一个内置对象，只需要知道对象中有哪些成员，有什么功能，直接使用，可通过MDN / W3C查询

（1）参考文档MDN

Mozilla 开发者网络（MDN）提供有关开放网络技术（Open Web）的信息，包括 HTML、CSS 和万维网及 HTML5 应用的 API。

MDN：https://developer.mozilla.org/zh-CN/

（2）如何学习一个方法？

• 查阅该方法的功能
• 查看里面参数的意义和类型
• 查看返回值的意义和类型
• 通过demo进行测试

Math 数学对象

Math 数学对象不是一个构造函数，所以我们不需要new来调用，而是直接使用里面的属性和方法即可 。

Math 对象它具有数学常数和函数的属性和方法。

根据数学相关的运算来找 Math 中的成员（求绝对值，取整）

Math.PI → 圆周率

Math.random() → 生成随机数

Math.floor() / Math.ceil() → 向下取整 / 向上取整

Math.round() → 取整，四舍五入

Math.abs() → 绝对值

Math.max() / Math.min() → 求最大和最小值

Math.sin() / Math.cos() → 正弦 / 余弦

Math.pow() / Math.sqrt() → 求指数次幂 / 求平方根

undefined参与取值是NaN，null参与取值是0

（1）绝对值方法

console.log(Math.abs('-1'));  // 隐式转换 会把字符串的-1转换为数字型
console.log(Math.abs(-1)); // 1
console.log(Math.abs("pink")); // NaN
console.log(Math.abs(undefined)); // NaN
console.log(Math.abs(null)); // 0
1
2
3
4
5

（2）三个取整方法

Math.floor() → floor地板，向下取整，往最小了取值

console.log(Math.floor(1.1)); // 1
console.log(Math.floor(1.9)); // 1
console.log(Math.floor(-1.1)); // -2
1
2
3

Math.ceil() → ceil天花板，向上取整，往最大了取值

console.log(Math.ceil(1.1)); // 2
console.log(Math.ceil(1.9)); // 2
console.log(Math.ceil(-1.1)); // -1
1
2
3

Math.round() → 四舍五入（其他数字都是四舍五入，但.5特殊，往大了取）

console.log(Math.round(1.1)); // 1
console.log(Math.round(1.9)); // 2
console.log(Math.round(-1.1)); // -1
console.log(Math.round(-1.9)); // -2
console.log(Math.round(1.5)); // 2
console.log(Math.round(-1.5)); // -1 （-1 > -2）
1
2
3
4
5
6

（3）最大值和最小值没有参数时

console.log(Math.max()); // -Infinity
console.log(Math.min()); // Infinity
1
2

（4）指数次幂pow / 平方根sqrt

// 求一个数的几次方
console.log(Math.pow(3, 4)); // 81
console.log(Math.pow(4, 1 / 2)); // 2 等价于4的平方根
// 平方根
console.log(Math.sqrt(4)); // 2
1
2
3
4
5

（5）随机数方法 Math.random()

Math.random() 返回一个随机的小数，0 <= x <1，此方法里不跟参数

// 得到两个数之间的随机整数（包含这两个整数）
function getRandomIntInclusive(min, max) {
  min = Math.ceil(min);
  max = Math.floor(max);
  return Math.floor(Math.random() * (max - min + 1)) + min; 
  // 分析：11 * [0 , 1) + 10 → [0 , 11) + 10 → [10 , 21) 向下取整得到 [10 , 20]
}
1
2
3
4
5
6
7

案例：随机点名

function getRandom(min, max) {
  min = Math.ceil(min);
  max = Math.floor(max);
  return Math.floor(Math.random() * (max - min + 1)) + min; 
}
var arr = ['zs','ls','lw','zl'];
console.log(arr[getRandom(0, arr.length-1)]);
1
2
3
4
5
6
7

案例：猜数字游戏（1~10之间随机整数，用户猜）

function getRandom(min, max) {
	min = Math.ceil(min);
    max = Math.floor(max);
    return Math.floor(Math.random() * (max - min + 1)) + min;
}
var random = getRandom(1, 10);
while (true) {
  var num = prompt("你来猜？输入1~10之间的一个整数");
  if (num > random) {
    alert("你猜大了");
  } else if (num < random) {
    alert("你猜小了");
  } else {
    alert("你猜对了");
    break;
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

Date 日期对象

Date对象和Math不一样，Date是一个构造函数，必须使用new来调用创建日期对象。

var date = new Date();

Date实例用来处理日期和时间

（1）Date() 方法的使用

获取当前时间必须实例化（若没有参数，返回当前系统的当前时间）

var now = new Date();
console.log(now); // 例如：Wed Jun 09 2021 14:18:06 GMT+0800 (中国标准时间)
1
2

Date() 构造函数的参数：若()里有时间，就返回参数里面的时间，参数常用的写法，数字型 2021，06，09 或者是字符串型 ‘2021-6-9 14：23：8’

var date1 = new Date(2021, 6, 9);
console.log(date1);  // Fri Jul 09 2021 00:00:00 GMT+0800 (中国标准时间) 返回的是5月，不是6月（因为计算机月份是0~11月）
var date2 = new Date("2021-6-9 14:29:8");
console.log(date2);  // Wed Jun 09 2021 14:29:08 GMT+0800 (中国标准时间)
1
2
3
4

（2）日期格式化（如：2021-6-9 14:29:8 这种格式）

getFullYear() → 获取当年

getMonth() → 获取当月（0~11）记得 +1

getDate() → 获取当天日期

getDay() → 获取星期几（周日 0 ~ 周六 6）

getHours() → 获取当前小时

getMinutes() → 获取当前分钟

getSeconds() → 获取当前秒钟

注意：返回的月份小1个月，记得月份+1；周一返回1，周六返回6，周日返回0

案例：写一个2021年6月9日 星期三

var date = new Date();
var year = date.getFullYear();
var month = date.getMonth() + 1;
var dates = date.getDate();
// 写个数组，通过索引号 0~6 调出
var arr = [
  "星期日",
  "星期一",
  "星期二",
  "星期三",
  "星期四",
  "星期五",
  "星期六",
];
var day = date.getDay();
console.log("今天是" + year + "年" + month + "月" + dates + "日" + arr[day]);  // 今天是2021年6月9日星期三
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

案例：要求封装一个函数返回当前的时分秒（格式：14:50:09）

function getTimer() {
  // 写getTimer()是为了不与getTime()冲突
  var time = new Date();
  var h = time.getHours();
  h = h < 10 ? "0" + h : h;
  var m = time.getMinutes();
  m = m < 10 ? "0" + m : m;
  var s = time.getSeconds();
  s = s < 10 ? "0" + s : s;
  return h + ":" + m + ":" + s;
}
console.log(getTimer());  // 14:54:09
1
2
3
4
5
6
7
8
9
10
11
12

（3）获取日期的总的毫秒形式（时间戳）

Date对象是基于1970年1月1日（世界标准时间）起的毫秒数

在程序里，所有的起始时间都是定为1970年1月1日

我们经常利用总的毫秒数来计算时间，因为它更准确

• 通过valueof()、getTime()

  var date = new Date();
  console.log(date.valueOf()); 
  console.log(date.getTime()); 
  // 1623222126739 我们现在时间距离1970.1.1的总毫秒数
  1
  2
  3
  4

• 简单的写法（最常用的写法）

  var date1 = +new Date();
  console.log(date1);
  1
  2

• H5新增的（有兼容问题）

  console.log(Date.now());
  1

案例：倒计时***

核心算法：输入的时间减去现在的时间就是剩余的时间，即倒计时，但不能拿时分秒相减，比如：05分 - 25分，结果会是负数（1秒=1000毫秒）

计算天数：d = parseInt(总秒数 / 60 / 60 / 24);

计算小时：h = parseInt(总秒数 / 60 / 60 % 24);

计算分数：m = parseInt(总秒数 / 60 % 60);

计算秒数：s = parseInt(总秒数 % 60);

function countDown(time) {
  var nowTime = +new Date(); // 返回当前时间总毫秒数
  var inputTime = +new Date(time); // 返回用户输入时间总毫秒数
  var times = (inputTime - nowTime) / 1000; // times是剩余时间总秒数
  var d = parseInt(times / 60 / 60 / 24);
  d = d < 10 ? "0" + d : d;
  var h = parseInt((times / 60 / 60) % 24);
  h = h < 10 ? "0" + h : h;
  var m = parseInt((times / 60) % 60);
  m = m < 10 ? "0" + m : m;
  var s = parseInt(times / 60 / 60 / 24);
  s = s < 10 ? "0" + s : s;
  return d + "天" + h + "时" + m + "分" + s + "秒";
}
console.log(countDown("2021-6-15 12:11:55"));
// 05天20时34分05秒
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

Array 数组对象

（1）创建数组对象的两种方式

字面量方式 var arr = [1,2,3];

new Array() 构造函数方法

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

（2）检测数组类型

instanceof ——检测某个实例是否是某个对象类型（运算符）

var arr = [];
var obj = {};
console.log(arr instanceof Array); // true
console.log(obj instanceof Array); // false
1
2
3
4

Array.isArray(参数)，ie9以上支持（H5新增） ，优先于instanceof

console.log(Array.isArray(arr));  // true
console.log(Array.isArray(obj));  // false
1
2

案例：优化之前的翻转数组

function reverse(arr) {
  // if(arr instanceof Array) 或者是
  if (Array.isArray(arr)) {
    var newArr = [];
    for (var i = arr.length - 1; i >= 0; i--) {
      newArr[newArr.length] = arr[i];
    }
    return newArr;
  } else {
    return "error 这个参数要求必须是数组格式[1,2,3]";
  }
}
console.log(reverse([1, 2, 3])); // [3,2,1]
console.log(reverse(1, 2, 3)); // 输出else
1
2
3
4
5
6
7
8
9
10
11
12
13
14

（3）数组转换为字符串

toString() → 把数组转换成字符串，逗号分隔每一项

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

join(‘分隔符’) → 将数组的所有元素连接到一个字符串中，可选择用哪种分隔符

var arr = ['green','blue','pink'];
console.log(arr.join());  // green,blue,pink（默认是逗号）
console.log(arr.join('-'));  // green-blue-pink
console.log(arr.join('&'));  // green&blue&pink
1
2
3
4

（4）数组常用方法（会影响原数组）

首尾数据操作：原数组也会发生变化

push() → 在数组末尾添加一个或多个元素，并返回数组操作后的长度

pop() → 无参数，删除数组最后一项，返回删除项

shift() → 无参数，删除数组第一项，返回删除项

unshift() → 在数组开头添加一个或多个元素，并返回数组的新长度

var arr = [1,2,3,4];
// 首尾操作方法
// 尾推 参数是随意的 可以有一个或多个
console.log(arr.push(5, 6, 7, 8));  // 输出 8
console.log(arr);  // [1,2,3,4,5,6,7,8]
1
2
3
4
5

var arr = [1,2,3,4];
// 尾删 删除最后一项数据
// 不需要传参
console.log(arr.pop());  // 4
console.log(arr); // [1,2,3]
1
2
3
4
5

var arr = [1,2,3,4];
// 首删 删除第一项数据
// 不需要传参
console.log(arr.shift());  // 1
console.log(arr);  // [2,3,4]
1
2
3
4
5

var arr = [1,2,3,4];
// 首添 参数与push方法类似
console.log(arr.unshift(-1, 0));  // 6
console.log(arr);  // [-1,0,1,2,3,4]
1
2
3
4

案例：首尾操作

var arr = [1, 2, 3, 4];
// 将数组的第一项移动到最后一项
arr.push(arr.shift());
console.log(arr);  // [2,3,4,1]

// 将数组的最后一项移动到第一项
arr.unshift(arr.pop());
console.log(arr);  // [1,2,3,4]
1
2
3
4
5
6
7
8

案例：把数组中 >2000 的删除，剩余的放到新数组中

var arr = [1500, 1200, 1800, 2500, 1600, 3000];
var newArr = [];
for (var i = 0; i <= arr.length - 1; i++) {
  if (arr[i] < 2000) {
    // newArr[newArr.length]=arr[i];
    newArr.push(arr[i]);
  }
}
console.log(newArr); // [1500,1200,1800,1600]
1
2
3
4
5
6
7
8
9

（5）合并和拆分（不影响原数组）

concat()

• 将两个数组合并成一个新的数组，原数组不受影响。
• 参数位置可以是一个数组字面量、数组变量、零散的值。

var arr = [1, 2, 3, 4];
// 合并方法
// 参数：数组、数组的变量、零散的值
// 返回值：一个新的拼接后的数组

// 参数是数组
var arr1 = arr.concat([5, 6, 7]);  // [1,2,3,4,5,6,7]

// 参数是数组变量
var ar = ["blue", "red", "pink"];
var arr1 = arr.concat(ar); // [1,2,3,4,"blue","red","pink"] 

// 参数是零散的值
var arr1 = arr.concat(11, 12, 13);  // [1,2,3,4,11,12,13]
console.log(arr);  // [1,2,3,4]原数组不会变化
console.log(arr1); 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

slice(start,end)

• 从当前数组中截取一个新的数组，不影响原来的数组，返回一个新的数组，包含从 start 到 end （不包括该元素）的元素。
• 参数区分正负，正值表示下标位置（从0开始数），负值表示从后面往前数第几个位置（从1开始数），参数可以只传递 一个，表示从开始位置截取到字符串结尾

var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
// 拆分方法
// 参数为正，下标位置，从0开始数
var arr1 = arr.slice(3, 7);  // [4,5,6,7]

// 参数为负，倒数第几个，从1开始数
var arr1 = arr.slice(-7, -3);  // [4,5,6,7]

// 只写一个参数
var arr1 = arr.slice(7);  // [8,9,10]
var arr1 = arr.slice(-7); // [4,5,6,7,8,9,10]
console.log(arr); // 原数组不会发生变化
console.log(arr1);
1
2
3
4
5
6
7
8
9
10
11
12
13

（6）删除、插入、替换（会影响原数组）**

splice(index,howmany,element1,element2,……)

• 用于插入、删除或替换数组的元素
• index：删除元素的开始位置
• howmany：删除元素的个数，可以是0
• element1,element2：要替换的新的数据
• 注意：插入元素时，第二个参数必须为0

var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
// 删除功能 传前两个参数
console.log(arr.splice(2, 3));  // [3,4,5]
console.log(arr); // [1,2,6,7,8,9,10]

// 替换功能，传3个及以上的参数
arr.splice(2, 3, "haha", "heihei"); 
console.log(arr);  // [1,2,"hah a","heihei",9,10]

// 插入功能 传3个及以上的参数 但是第2个参数必须为0
arr.splice(2, 0, "hi");
console.log(arr);  // [1,2,"hi","haha","heihei", 9,10]
1
2
3
4
5
6
7
8
9
10
11
12

（7）位置方法

indexOf() → 查找数据在数组中最先出现的下标

lastIndexOf() → 查找数据在数组中最后一次出现的下标

注意：如果没找到返回-1

var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 4, 5];
// indexOf() 返回该数组元素从前往后第一次出现位置的下标
console.log(arr.indexOf(4));  // 3

// lastIndexOf() 返回该数组元素从前往后最后一次出现位置的下标
console.log(arr.lastIndexOf(4));  // 10
1
2
3
4
5
6

（8）倒序（会影响原数组）

reverse() → 无参数，将数组完全颠倒，第一项变成最后一项，最后一项变成第一项。

var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 20, 30];
// 倒序排列
console.log(arr.reverse()); 
// [30, 20, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
console.log(arr);
// [30, 20, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
1
2
3
4
5
6

（9）排序

sort(); → 默认根据字符编码顺序，从小到大排序

• 如果想要根据数值大小进行排序，必须添加sort的比较函数参数。
• 该函数要比较两个值，然后返回一个用于说明这两个值的相对顺序的数字。
• 比较函数应该具有两个参数 a 和 b，根据a和b的关系作为判断条件，返回值根据条件分为三个分支，正数、 负数、0
• 返回值是负数-1：a排在b前面。
• 返回值是正数1：a排在b后面。
• 返回值是0：a和b的顺序保持不变。
• 人为能控制的是判断条件。

var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 20, 30];
// 排序 默认按照字符编码顺序从小到大排列
arr.sort();  // [1, 10, 2, 20, 3, 30, 4, 5, 6, 7, 8, 9]

arr.sort(function (a, b) {
if (a > b) {
	// a > b成立的话是降序，若是a < b则是升序
    return -1; // 表示 a 要排在 b 的前面
} else if (a < b) {
	return 1; // 表示 a 要排在 b 的后面
} else {
    return 0; // 表示 a 和 b 保持原样 不换位置
}
});
console.log(arr);  // [30, 20, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 20, 30];
arr.sort(function (a, b) {
	// return a - b;  升序的排列方式
    return b - a;  // 降序的排列方式
});
console.log(arr); // [30, 20, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
1
2
3
4
5
6

（10）清空数组

方式1（推荐）： arr = [];

方式2 ： arr.length = 0;

方式3 ： arr.splice(0, arr.length);

案例：数组去重

// 目标：把旧数组里不重复的元素选取出来放到新数组中，重复元素只保留一个，放到新数组中去重
// 核心算法：遍历旧数组，然后拿着旧数组元素去查询新数组，若该元素在新数组中没有出现过，我们就添加，否则不添加
// 如何知道该元素没有存在？利用 新数组.indexOf(数组元素)，若返回-1，就说明数组里没有该元素
function unique(arr) {
  var newArr = [];
  for (var i = 0; i <= arr.length - 1; i++) {
    if (newArr.indexOf(arr[i]) === -1) {
      newArr.push(arr[i]);
    }
  }
  return newArr;
}
var demo = unique([1, 2, 2, 3, "blue", "pink", "pink"]);
console.log(demo); // [1,2,3,"blue", "pink"]
1
2
3
4
5
6
7
8
9
10
11
12
13
14

String 对象

（1）基本包装类型

为了方便操作简单数据类型，JavaScript 提供了特殊的简单类型对象：String

基本类型是没有方法的。

当调用 str.substring() 等方法的时候，先把 str 包装成 String 类型的临时对象，再调用substring 方法，最后销毁临时对象。

可以使用 new String() 构造函数方法创建字符串对象

// 字符串也有一种根据构造函数创建的方法
var str = new String("abcdef");
console.log(str);

// 基本数据类型：没有属性和方法
// 对象数据类型：有属性和方法
// 但是字符串是可以调用一些属性和方法
// 基本包装类型：基本数据类型在进行一些特殊操作时，会暂时被包装成一个对象，结束后再被销毁
var str = "这是一个字符串";
var str2 = str.slice(3, 5);
console.log(str2)

// 模拟计算机的工作
var str = "这是一个字符串";
// 进行了一个临时的包装
var str3 = new String(str); // 生成临时变量 把简单数据类型包装成复杂数据类型
var str2 = str3.slice(3, 5);
str3 = null; // 销毁这个临时变量
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

（2）字符串的特点

字符串是不可变的。指里面的值不可变，虽然看上去可以改变内容，但其实是地址变了，内存中新开辟了一个内存空间。

var str = 'abc';
str = 'hi';
// 当重新给str赋值时，常量'abc'不会被修改，依然存在内存中
// 重新给字符串赋值，会重新在内存中开辟空间，这个特点就是字符串的不可变
1
2
3
4

由于字符串的不可变，在大量拼接字符串的时候会有效率问题。

var str = '';
for (var i = 0; i<100000; i++) {
	str += i; // 甚至可能死机
}
console.log(str); // 需花费大量时间，因为需要不断开辟新的空间
1
2
3
4
5

注意：字符串所有的方法，都不会修改字符串本身（字符串是不可变的），操作完成会返回一个新的字符串。

（3）字符串属性

长度属性：str.length

字符串长度指的是一个字符串中所有的字符总数。

var str = "这是一个普通的字符串，abc,   ￥%#";
console.log(str.length);  // 21
1
2

（4）根据位置返回字符

charAt(index) → 可返回指定下标位置的字符。

• char：charator，字符
• at：在哪儿
• 参数是 index 字符串的下标。也是从 0 开始。
• 表示返回指定的下标位置的字符

var str = "这是一个普通的字符串，abc,   ￥%#";
console.log(str.charAt(6)); // 的
// 遍历所有的字符
for (var i =0; i <str.length; i++) {
    console.log(str.charAt(i));
}
1
2
3
4
5
6

charCodeAt(index) → 可返回指定下标位置处字符的ASCII码。

• ASCII值的目的：判断用户按下了哪个键
• 小写a的ASCII值=65；大写A=a+32=97

var str1 = 'andy';
console.log(str.charCodeAt(0));  // 97
1
2

str[index] → 获取指定位置处字符（H5新增，兼容问题，IE8+支持，和charAt(）等效

var str1 = 'andy';
console.log(str[0]);  // a
1
2

案例：判断一个字符串中出现次数最多的字符，并统计其次数

// 核心算法：用charAt()遍历这个字符串
// 把每个字符都存储给对象，若对象没有该属性，就为1，存在了就+1
// 遍历对象，得到最大值和该字符
var str = "abcoefoxyozzopx";
var o = {};
for (var i = 0; i < str.length; i++) {
	var chars = str.charAt(i); // chars是字符串的每一个字符
    if (o[chars]) {  // o[chars]得到的是属性值（若此处写o.chars得到的是'a'字符串形式，本来o['chars']也是得到'a'，而o[chars]得到的就是去了引号的a）
    	o[chars]++;
    } else {
    	o[chars] = 1;
    }
}
console.log(o); // {a: 1, b: 1, c: 1, o: 4, e: 1, …}统计了每个字符的次数
var max = 0;
var ch = ""; // 因为 k 只有在for循环中才有效，所以声明一个变量
for (var k in o) {
	// 遍历对象（k得到的是属性名，o[k]得到的才是属性值）
    if (o[k] > max) {
    	max = o[k];
        ch = k;
    }
}
console.log(max); // 4
console.log("最多的字符是" + ch); // 最多的字符是o
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

（5）根据字符返回位置

indexOf( ‘要查找的字符’ , [起始的位置] ) → 中括号指可选，可写也可省略

• 可返回某个指定的字符串值在字符串中首次出现的位置。
• 找到指定的子字符串在原字符串中第一次出现的位置的下标。
• 若有第二个参数，则表示从指定索引号开始往后查找
• 如果子字符串在原字符串中没有，返回值是 -1

var str = '这是一个字符串，字符串';
console.log(str.indexOf("字符串")); // 4
console.log(str.indexOf("字", 5)); // 8
console.log(str.indexOf("a")); // -1
1
2
3
4

LastIndexOf() → 从后往前找，只找第一个匹配的，然后返回下标，找不到返回-1

var str3 = "这是一个字符串，字符串";
console.log(str3.lastIndexOf("字符串")); // 8
console.log(str3.lastIndexOf("，")); // 7
1
2
3

案例：查找字符串"abcoefoxyozzopk"中所有o出现的位置及次数

// 核心算法：先查找第一个o出现的位置
// 只要indeOf返回的结果不是-1，就继续往后查找
// 因为indexOf只能查找第一个，所以后面的查找，利用第二个参数，当前索引+1，从而继续查找
var str = "abcoefoxyozzopk";
var index = str.indexOf("o");
var num = 0;
while (index !== -1) {
    // 因为第一次查找没有输出 所以要在前面写
	console.log(index); // 3,6,9,12
    num++;
    index = str.indexOf("o", index + 1);
}
console.log("o出现的次数是：" + num); // o出现的次数是：4
1
2
3
4
5
6
7
8
9
10
11
12
13

（6）字符串操作方法***

concat(‘字符串1’ , ‘字符串2’ , ……) → 用于连接两个或多个字符串

• 参数比较灵活，可以是字符串、或者字符串变量、多个字符串。
• 等效于+，+更常用
• 生成的是一个新的字符串，原字符串不发生变化

var str = "andy";
console.log(str.concat("red", 4, 5)); // andyred45
1
2

split(‘分隔符’) → 用于把一个字符串分割成字符串数组。

• 参数部分是分割符，利用分割符将字符串分割成多个部分，多个部分作为数组的每一项组成数组。
• 参数取决于字符串是用什么分隔符隔开的
• 如果分割符是空字符串，相当于将每个字符拆分成数组中的每一项

var str = "red,pink,blue";
var arr = str.split(",");
console.log(arr); // ["red","pink","blue"]
var arr1 = str.split("");
console.log(arr1); // ["r", "e", "d", ",", "p", "i", "n", "k", ",", "b", "l", "u", "e"]

var str1 = "red&pink&blue";
var arr2 = str1.split("&");  
console.log(arr2);  // ["red","pink","blue"]
1
2
3
4
5
6
7
8
9

// 字符串内容倒置
var str = "我是字符串";
//   var arr = str.split("");
//   arr.reverse();
//   str = arr.join("");
// 化简写法
str = str.split("").reverse().join("");
console.log(str); // 串符字是我
1
2
3
4
5
6
7
8

toLowerCase() → 把字符串转换为小写。

toUpperCase() → 把字符串转换为大写。

• 将所有的英文字符转为大写或者小写。
• 生成的是新的字符串，原字符串不发生变化

var str = "abc";
var str1 = str.toUpperCase();
var str2 = str.toLowerCase();
console.log(str1);  // ABC
console.log(str2);  // abc
1
2
3
4
5

slice(start，end) → 可提取字符串的某个部分，并以新的字符串返回被提取的部分。

• 从start截取到end（不包括end）的字符串。 start和end都是索引号
• 参数区分正负，正值表示下标位置，负值表示从后面往前数第几个位置
• 参数可以只传递 一个，表示从开始位置截取到字符串结尾

// 截取字符串
var str = "我是字符串,  abc";
var str1 = str.slice(3, 9);
console.log(str1); // 符串,  a

var str2 = str.slice(-7, -2);
console.log(str2); // 串,  a

var str3 = str.slice(-7);
console.log(str3); // 串,  abc
1
2
3
4
5
6
7
8
9
10

** substr(start,howmany) → 可在字符串中抽取从 start 下标开始的指定数目的字符。

• 从开始位置截取到指定长度的字符串。
• start 参数区分正负。正值表示下标位置，负值表示从后往前数第几个位置。
• howmany 参数必须为正数，也可以不写，不写表示从 start 截取到最后

var str = "我是字符串,  abc";
var str1 = str.substr(3, 6);
console.log(str1); // 符串,  a
var str2 = str.substr(-8, 6);
console.log(str2); // 符串，  a
var str3 = str.substr(-8);
console.log(str3); // 符串，  abc
1
2
3
4
5
6
7

substring(start,end) → 用于提取字符串中介于两个指定下标之间的字符。

• 参数只能为正数。
• 两个参数都是指代下标，两个数字大小不限制，执行方法之前会比较一下两个参数的大小， 会用小的当做开始位置，大的当做结束位置，从开始位置截取到结束位置但是不包含结束位置。
• 如果不写第二个参数，从开始截取到字符串结尾

var str = "我是字符串,  abc";
var str1 = str.substring(3, 9);
console.log(str1); // 符串，  a
var str2 = str.substring(9, 3);
console.log(str2); // 符串，  a（执行时会用会用小的当做开始位置，大的当做结束位置）
var str3 = str.substring(5);
console.log(str3); // ,  abc
1
2
3
4
5
6
7