JavaScript数组和字符串方法_查找字符和数组js-优快云博客

本文链接：https://blog.youkuaiyun.com/achen0507/article/details/129284764

本文详细介绍了JavaScript中数组的方法，如concat()、copyWithin()、entries()、every()等，以及字符串的方法，如charAt()、indexOf()、includes()等。这些方法涵盖了数组的连接、拷贝、迭代、过滤、查找和转换等多种操作，同时也概述了字符串的查找、替换、分割和大小写转换等功能。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一、数组方法总结

1、concat()

方法：连接两个或更多的数组，并返回结果。

// 语法：
array1.concat(array2, array3,..., arrayX)

// 示例：
var a = ["季沧海", "崔三娘"];
var b = ["顾清寒", "宁红夜"];
var c = a.concat(b);
document.write(c);

// 输出结果：季沧海,崔三娘,顾清寒,宁红夜

2、copyWithin()

方法：从数组的指定位置拷贝元素到数组的另一个指定位置中。

// 语法：
array.copyWithin(target, start, end)

// 参数：
// target:必需。复制到指定目标索引位置。
// start:可选。元素复制的起始位置。
// end:可选。停止复制的索引位置 (默认为 array.length)。如果为负值，表示倒数。

// 示例：
// 复制数组的前面两个元素到后面两个元素上:
var fruits = ["季沧海", "崔三娘", "顾清寒", "宁红夜"];
fruits.copyWithin(2, 0);

// 输出结果：季沧海,崔三娘,顾清寒,宁红夜

3、entries()

方法：返回数组的可迭代对象，该对象包含数组的键值对 (key/value)。

// 语法：
array.entries()

// 示例：
var fruits = ["季沧海", "崔三娘", "顾清寒", "宁红夜"];
fruits.entries();

// 输出结果：Array Iterator {}
[0, "季沧海"]
[1, "崔三娘"]
[2, "顾清寒"]
[3, "宁红夜"]

4、every()

方法：检测数值元素的每个元素是否都符合条件。

// 语法：
array.every(function(currentValue,index,arr), thisValue)

// 参数：
// function(currentValue, index,arr) 必须。函数，数组中的每个元素都会执行这个函数
	// 函数参数:
	// currentValue	必须。当前元素的值
	// index	可选。当前元素的索引值
	// arr	可选。当前元素属于的数组对象

// thisValue	可选。对象作为该执行回调时使用，传递给函数，用作 "this" 的值。如果省略了 thisValue ，"this" 的值为 "undefined"

// 示例：
// 检测数组 ages 的所有元素是否都大于等于 18 :
var ages = [17, 19, 20, 21];

function checkAdult(age) {
    return age >= 18;
}

function myFunction() {
    document.getElementById("demo").innerHTML = ages.every(checkAdult);
}

// 输出结果：false

5、fill()

方法：使用一个固定值来填充数组。

// 语法：
array.fill(value, start, end)

// 参数：
// value	必需。填充的值。
// start	可选。开始填充位置。
// end	可选。停止填充位置 (默认为 array.length)

// 示例：
var fruits = ["顾清寒", "宁红夜"];
fruits.fill("顾清寒");

// 输出结果：顾清寒,顾清寒

6、filter()

方法：检测数值元素，并返回符合条件所有元素的数组。

// 语法：
array.filter(function(currentValue,index,arr), thisValue)

// 参数：
// function(currentValue, index,arr) 必须。函数，数组中的每个元素都会执行这个函数
	// 函数参数:
	// currentValue	必须。当前元素的值
	// index	可选。当前元素的索引值
	// arr	可选。当前元素属于的数组对象

// thisValue	可选。对象作为该执行回调时使用，传递给函数，用作 "this" 的值。如果省略了 thisValue ，"this" 的值为 "undefined"

// 示例：
// 返回数组 ages 中所有元素都大于 18 的元素:
var ages = [17, 19, 20, 21];

function checkAdult(age) {
    return age >= 18;
}

function myFunction() {
    document.getElementById("demo").innerHTML = ages.filter(checkAdult);
}

// 输出结果：19,20,21

7、find()

方法：返回通过测试（函数内判断）的数组的第一个元素的值。

// 语法：
array.find(function(currentValue, index, arr),thisValue)

// 参数：
// function(currentValue, index,arr) 必须。函数，数组中的每个元素都会执行这个函数
	// 函数参数:
	// currentValue	必须。当前元素的值
	// index	可选。当前元素的索引值
	// arr	可选。当前元素属于的数组对象

// thisValue	可选。对象作为该执行回调时使用，传递给函数，用作 "this" 的值。如果省略了 thisValue ，"this" 的值为 "undefined"

// 示例：
// 获取数组中年龄大于 18 的第一个元素:
var ages = [17, 19, 20, 21];
 
function checkAdult(age) {
    return age >= 18;
}
 
function myFunction() {
    document.getElementById("demo").innerHTML = ages.find(checkAdult);
}

// 输出结果：19

8、findIndex()

方法：返回传入一个测试条件（函数）符合条件的数组第一个元素位置。

// 语法：
array.findIndex(function(currentValue, index, arr), thisValue)

// 参数：
// function(currentValue, index,arr) 必须。函数，数组中的每个元素都会执行这个函数
	// 函数参数:
	// currentValue	必须。当前元素的值
	// index	可选。当前元素的索引值
	// arr	可选。当前元素属于的数组对象

// thisValue	可选。对象作为该执行回调时使用，传递给函数，用作 "this" 的值。如果省略了 thisValue ，"this" 的值为 "undefined"

// 示例：
var ages = [17, 19, 20, 21];
 
function checkAdult(age) {
    return age >= 18;
}
 
function myFunction() {
    document.getElementById("demo").innerHTML = ages.findIndex(checkAdult);
}

// 输出结果：1

9、forEach()

方法：用于调用数组的每个元素，并将元素传递给回调函数。

// 语法：
array.forEach(callbackFn(currentValue, index, arr), thisValue)

// 参数：
// callbackFn(currentValue, index, arr)	必需。 数组中每个元素需要调用的函数。
	// 函数参数：
	// currentValue	必需。当前元素
	// index	可选。当前元素的索引值。
	// arr	可选。当前元素所属的数组对象。
// thisValue	可选。传递给函数的值一般用 "this" 值。如果这个参数为空， "undefined" 会传递给 "this" 值

// 示例：
// 列出数组的每个元素：
<button onclick="numbers.forEach(myFunction)">点我</button>
<p id="demo"></p>
 
<script>
demoP = document.getElementById("demo");
var numbers = [17, 19, 20, 21];
 
function myFunction(item, index) {
    demoP.innerHTML = demoP.innerHTML + "index[" + index + "]: " + item + "<br>"; 
}
</script>

// 输出结果：
index[0]: 17
index[1]: 19
index[2]: 20
index[3]: 21

10、from()

方法：用于通过拥有 length 属性的对象或可迭代的对象来返回一个数组。

// 语法：
Array.from(object, mapFunction, thisValue)

// 参数：
// object	必需，要转换为数组的对象。
// mapFunction	可选，数组中每个元素要调用的函数。
// thisValue	可选，映射函数(mapFunction)中的 this 对象。

// 示例：
// 通过字符串创建一个数组：
var myArr = Array.from("ARY1");

11、includes()

方法：用来判断一个数组是否包含一个指定的值，如果是返回 true，否则false。

// 语法：
arr.includes(searchElement)
arr.includes(searchElement, fromIndex)

// 参数：
// searchElement	必须。需要查找的元素值。
// fromIndex	可选。从该索引处开始查找 searchElement。如果为负值，则按升序从array.length + fromIndex 的索引开始搜索。默认为 0。

// 示例：
let site = ['aaa', 'bbb', 'ccc'];
site.includes('bbb'); 

// 输出结果：true

12、indexOf()

方法：可返回数组中某个指定的元素位置。

// 语法：
array.indexOf(item,start)

// 参数：
// item	必须。查找的元素。
// start	可选的整数参数。规定在数组中开始检索的位置。它的合法取值是 0 到stringObject.length - 1。如省略该参数，则将从字符串的首字符开始检索。

// 示例：
var fruits = ["Banana", "Orange", "Apple", "Mango"];
var a = fruits.indexOf("Apple");

// 输出结果：2

13、isArray()

方法：用于判断一个对象是否为数组。

// 语法：
Array.isArray(obj)

// 参数：
// obj	必需，要判断的对象。

// 示例：
function myFunction() {
    var fruits = ["Banana", "Orange", "Apple", "Mango"];
    var x = document.getElementById("demo");
    x.innerHTML = Array.isArray(fruits);
}

// 输出结果：true

15、join()

方法：用于把数组中的所有元素转换一个字符串。

// 语法：
array.join(separator)

// 参数：
// separator	可选。指定要使用的分隔符。如果省略该参数，则使用逗号作为分隔符。

// 示例：
var fruits = ["Banana", "Orange", "Apple", "Mango"];
var energy = fruits.join();

// 输出结果：Banana,Orange,Apple,Mango

16、keys()

方法：用于从数组创建一个包含数组键的可迭代对象。

// 语法：
array.keys()

// 示例：
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.keys();

// 输出结果：Array Iterator {}

17、lastIndexOf()

方法：可返回一个指定的元素在数组中最后出现的位置，从该字符串的后面向前查找。

// 语法：
array.lastIndexOf(item,start)

// 参数：
// item	必需。规定需检索的字符串值。
// start	可选的整数参数。规定在字符串中开始检索的位置。它的合法取值是 0 到 stringObject.length - 1。如省略该参数，则将从字符串的最后一个字符处开始检索。

// 示例：
var fruits = ["Banana", "Orange", "Apple", "Mango"];
var a = fruits.lastIndexOf("Apple");

// 输出结果：2

18、map()

方法：通过指定函数处理数组的每个元素，并返回处理后的数组。

// 语法：
array.map(function(currentValue,index,arr), thisValue)

// 参数：
// function(currentValue, index,arr)	必须。函数，数组中的每个元素都会执行这个函数
	// 函数参数:
	// currentValue	必须。当前元素的值
	// index	可选。当前元素的索引值
	// arr	可选。当前元素属于的数组对象
// thisValue	可选。对象作为该执行回调时使用，传递给函数，用作 "this" 的值。如果省略了 thisValue，或者传入 null、undefined，那么回调函数的 this 为全局对象。

// 示例：
// 返回一个数组，数组中元素为原始数组的平方根:
var numbers = [4, 9, 16, 25];

function myFunction() {
    x = document.getElementById("demo")
    x.innerHTML = numbers.map(Math.sqrt);
}

// 输出结果：2,3,4,5

19、pop()

方法：用于删除数组的最后一个元素并返回删除的元素。

// 语法：
array.pop()

// 示例：
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.pop();

// 输出结果：Banana,Orange,Apple

20、push()

方法：可向数组的末尾添加一个或多个元素，并返回新的长度。

// 语法：
array.push(item1, item2, ..., itemX)

// 参数：
// item1, item2, ..., itemX	必需。要添加到数组的元素。

// 示例：
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.push("Kiwi")

// 输出结果：Banana,Orange,Apple,Mango,Kiwi

21、reduce()

方法：将数组元素计算为一个值（从左到右）。

// 语法：
array.reduce(function(total, currentValue, currentIndex, arr), initialValue)

// 参数：
// function(total,currentValue, index,arr)	必需。用于执行每个数组元素的函数。
	// 函数参数:
		// total	必需。初始值, 或者计算结束后的返回值。
		// currentValue	必需。当前元素
		// currentIndex	可选。当前元素的索引
		// arr	可选。当前元素所属的数组对象。
// initialValue	可选。传递给函数的初始值

// 示例：
// 计算数组元素相加后的总和：
var numbers = [10, 20, 30, 40];
 
function getSum(total, num) {
    return total + num;
}
function myFunction(item) {
    document.getElementById("demo").innerHTML = numbers.reduce(getSum);
}
// 输出结果：100

22、reduceRight()

方法：将数组元素计算为一个值（从右到左）。

// 语法：
array.reduceRight(function(total, currentValue, currentIndex, arr), initialValue)

// 参数：
// function(total,currentValue, index,arr)	必需。用于执行每个数组元素的函数。
	// 函数参数:
		// total	必需。初始值, 或者计算结束后的返回值。
		// currentValue	必需。当前元素
		// currentIndex	可选。当前元素的索引
		// arr	可选。当前元素所属的数组对象。
// initialValue	可选。传递给函数的初始值

// 示例：
// 计算数组元素相加后的总和：
var numbers = [10, 20, 30, 40];
 
function getSum(total, num) {
    return total + num;
}
function myFunction(item) {
    document.getElementById("demo").innerHTML = numbers.reduceRight(getSum);
}
// 输出结果：100

23、reverse()

方法：用于颠倒数组中元素的顺序。

// 语法：
array.reverse()

// 示例：
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.reverse();

// 输出结果：Mango,Apple,Orange,Banana

24、shift()

方法：用于把数组的第一个元素从其中删除，并返回第一个元素的值。

// 语法：
array.shift()

// 示例：
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.shift()

// 输出结果：Orange,Apple,Mango

25、slice()

方法：选取数组的一部分，并返回一个新数组。

// 语法：
array.slice(start, end)

// 参数：
// start	可选。规定从何处开始选取。如果该参数为负数，则表示从原数组中的倒数第几个元素开始提取。
// end	可选。规定从何处结束选取。该参数是数组片断结束处的数组下标。如果没有指定该参数，那么切分的数组包含从 start 到数组结束的所有元素。如果该参数为负数， 则它表示在原数组中的倒数第几个元素结束抽取。

// 示例：
var fruits = ["Banana", "Orange", "Lemon", "Apple", "Mango"];
var citrus = fruits.slice(1,3);

// 输出结果：Orange,Lemon

26、some()

方法：检测数组元素中是否有元素符合指定条件。

// 语法：
array.some(function(currentValue,index,arr),thisValue)

// 参数：
// function(currentValue, index,arr)	必须。函数，数组中的每个元素都会执行这个函数
	// 函数参数:
		// currentValue	必须。当前元素的值
		// index	可选。当前元素的索引值
		// arr	可选。当前元素属于的数组对象
// thisValue	可选。对象作为该执行回调时使用，传递给函数，用作 "this" 的值。如果省略了 thisValue ，"this" 的值为 "undefined"

// 示例：
// 检测数组中是否有元素大于 18:
var ages = [17, 19, 20, 21];

function checkAdult(age) {
    return age >= 18;
}

function myFunction() {
    document.getElementById("demo").innerHTML = ages.some(checkAdult);
}

// 输出结果：true

27、sort()

方法：对数组的元素进行排序。

// 语法：
array.sort(sortfunction)

// 参数：
// sortfunction	可选。规定排序顺序。必须是函数。

// 示例：
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.sort();

// 输出结果：Apple,Banana,Mango,Orange

28、splice()

方法：从数组中添加或删除元素。

// 语法：
array.splice(index,howmany,item1,.....,itemX)

// 参数：
// index	必需。规定从何处添加/删除元素。该参数是开始插入和（或）删除的数组元素的下标，必须是数字。
// howmany	可选。规定应该删除多少元素。必须是数字，但可以是 "0"。如果未规定此参数，则删除从 index 开始到原数组结尾的所有元素。
// item1, ..., itemX	可选。要添加到数组的新元素

// 示例：
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.splice(2,0,"Lemon","Kiwi");

// 输出结果：Banana,Orange,Lemon,Kiwi,Apple,Mango

29、toString()

方法：把数组转换为字符串，并返回结果。

// 语法：
array.toString()

// 示例：
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.toString();

// 输出结果：Banana,Orange,Apple,Mango

30、unshift()

方法：向数组的开头添加一个或更多元素，并返回新的长度。

// 语法：
array.unshift(item1,item2, ..., itemX)

// 参数：
// item1,item2, ..., itemX	可选。向数组起始位置添加一个或者多个元素。

// 示例：
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.unshift("Lemon","Pineapple");

// 输出结果：Lemon,Pineapple,Banana,Orange,Apple,Mango

31、valueOf()

方法：返回数组对象的原始值。

// 语法：
array.valueOf()

// 示例：
var fruits = ["Banana", "Orange", "Apple", "Mango"];
var v=fruits.valueOf();

// 输出结果：Banana,Orange,Apple,Mango

二、字符串方法总结

1、charAt()

方法：返回在指定位置的字符。

// 语法：
string.charAt(index)

// 参数:
// index	必需。表示字符串中某个位置的数字，即字符在字符串中的位置。

// 示例：
var str = "HELLO WORLD";
var n = str.charAt(2)

// 输出结果：L

2、charCodeAt()()

方法：返回数组对象的原始值。

// 语法：
string.charCodeAt(index)

// 参数:
// index		必需。表示字符串中某个位置的数字，即字符在字符串中的下标。

// 示例：
var str = "HELLO WORLD";
var n = str.charCodeAt(0);

// 输出结果：72

3、concat()

方法：用于连接两个或多个字符串。

// 语法：
string.concat(string1, string2, ..., stringX)

// 参数:
// string1, string2, ..., stringX	必需。将被连接为一个字符串的一个或多个字符串对象。

// 示例：
var str1 = "Hello ";
var str2 = "world!";
var n = str1.concat(str2);

// 输出结果：Hello world!

4、endsWith()

方法：用来判断当前字符串是否是以指定的子字符串结尾的（区分大小写）。

// 语法：
string.endsWith(searchvalue, length)

// 参数:
// searchvalue	必需，要搜索的子字符串。
// length	设置字符串的长度。默认值为原始字符串长度 string.length。

// 示例：
let str = "Hello world";
str.endsWith("world")   // 返回 true
str.endsWith("World")   // 返回 false

5、fromCharCode()

方法：返回数组对象的原始值。

// 语法：
String.fromCharCode(n1, n2, ..., nX)

// 参数: 
// n1, n2, ..., nX	必需。一个或多个 Unicode 值，即要创建的字符串中的字符的 Unicode 编码。

// 示例：
var n = String.fromCharCode(65);

// 输出结果：A

6、indexOf()

方法：返回某个指定的字符串值在字符串中首次出现的位置。

// 语法：
string.indexOf(searchvalue,start)

// 参数: 
// searchvalue	必需。规定需检索的字符串值。
// start	可选的整数参数。规定在字符串中开始检索的位置。它的合法取值是 0 到 string Object.length - 1。如省略该参数，则将从字符串的首字符开始检索。

// 示例：
var str="Hello world, welcome to the universe.";
var n=str.indexOf("welcome");

// 输出结果：13

7、includes()

方法：用于判断字符串是否包含指定的子字符串。

// 语法：
string.includes(searchvalue, start)

// 参数: 
// searchvalue	必需，要查找的字符串。
// start	可选，设置从那个位置开始查找，默认为 0。

// 示例：
var str = "Hello world, welcome to the Runoob。";
var n = str.includes("Runoob");

// 输出结果：true

8、lastIndexOf()

方法：从后向前搜索字符串，并从起始位置（0）开始计算返回字符串最后出现的位置。

// 语法：
string.lastIndexOf(searchvalue,start)
// 参数：
// searchvalue	必需。规定需检索的字符串值。
// start	可选的整数参数。规定在字符串中开始检索的位置。它的合法取值是 0 到 stringObject.length - 1。如省略该参数，则将从字符串的最后一个字符处开始检索。

// 示例：
var str="I am from runoob，welcome to runoob site.";
var n=str.lastIndexOf("runoob");

// 输出结果：28

9、match()

方法：查找找到一个或多个正则表达式的匹配。

// 语法：
string.match(regexp)

// 参数：
// regexp	必需。规定要匹配的模式的 RegExp 对象。如果该参数不是 RegExp 对象，则需要首先把它传递给 RegExp 构造函数，将其转换为 RegExp 对象。

// 示例：
var str="The rain in SPAIN stays mainly in the plain"; 
var n=str.match(/ain/g);

// 输出结果：ain,ain,ain

10、repeat()

方法：复制字符串指定次数，并将它们连接在一起返回。

// 语法：
string.repeat(count)

// 参数：
// count	必需，设置要复制的次数。

// 示例：
var str = "Runoob";
str.repeat(2);

// 输出结果：RunoobRunoob

11、replace()

方法：在字符串中查找匹配的子串，并替换与正则表达式匹配的子串。

// 语法：
string.replace(searchvalue,newvalue)

// 参数：
// searchvalue	必须。规定子字符串或要替换的模式的 RegExp 对象。请注意，如果该值是一个字符串，则将它作为要检索的直接量文本模式，而不是首先被转换为 RegExp 对象。
// newvalue	必需。一个字符串值。规定了替换文本或生成替换文本的函数。

// 示例：
var str="Visit Microsoft! Visit Microsoft!";
var n=str.replace("Microsoft","Runoob");

// 输出结果：Visit Runoob!Visit Microsoft!

12、replaceAll()

方法：在字符串中查找匹配的子串，并替换与正则表达式匹配的所有子串。

// 语法：
const newStr = str.replaceAll(regexp|substr, newSubstr|function)

// 参数：
// regexp|substr	必须。规定子字符串或要替换的模式的 RegExp 对象。请注意，如果该值是一个字符串，则将它作为要检索的直接量文本模式，而不是首先被转换为 RegExp 对象。当使用一个 regex 时，您必须设置全局（"g"）标志， 否则，它将引发 TypeError："必须使用全局 RegExp 调用 replaceAll"。
// newSubstr|function	必需。一个字符串值。规定了替换文本或生成替换文本的函数。

// 示例：
var str="Visit Microsoft! Visit Microsoft!";
var n=str.replaceAll("Microsoft","Runoob");

// 输出结果：Visit Runoob!Visit Runoob!

13、search()

方法：查找与正则表达式相匹配的值。

// 语法：
string.search(searchvalue)

// 参数：
// searchvalue	必须。查找的字符串或者正则表达式。

// 示例：
var str="Visit Runoob!"; 
var n=str.search("Runoob");

// 输出结果：6

14、slice()

方法：提取字符串的片断，并在新的字符串中返回被提取的部分。

// 语法：
string.slice(start,end)

// 参数：
// start	必须。 要抽取的片断的起始下标，第一个字符位置为 0。如果为负数，则从尾部开始截取。
// end	可选。 紧接着要截取的片段结尾的下标。若未指定此参数，则要提取的子串包括 start 到原字符串结尾的字符串。如果该参数是负数，那么它规定的是从字符串的尾部开始算起的位置。

// 示例：
var str="Hello world!";
var n=str.slice(1,5);

// 输出结果：ello

15、split()

方法：把字符串分割为字符串数组。

// 语法：
string.split(separator,limit)

// 参数：
// separator	可选。字符串或正则表达式，从该参数指定的地方分割 string Object。
// limit	可选。该参数可指定返回的数组的最大长度。如果设置了该参数，返回的子串不会多于这个参数指定的数组。如果没有设置该参数，整个字符串都会被分割，不考虑它的长度。

// 示例：
var str="How are you doing today?";
var n=str.split(" ");

// 输出结果：How,are,you,doing,today?

16、startsWith()

方法：查看字符串是否以指定的子字符串开头。

// 语法：
string.startsWith(searchvalue, start)

// 参数：
// searchvalue	必需，要查找的字符串。
// start	可选，查找的开始位置，默认为 0。

// 示例：
var str = "Hello world, welcome to the Runoob.";
var n = str.startsWith("Hello");

// 输出结果：true

17、substr()

方法：从起始索引号提取字符串中指定数目的字符。

// 语法：
string.substr(start,length)

// 参数：
// start	必需。要抽取的子串的起始下标。必须是数值。如果是负数，那么该参数声明从字符串的尾部开始算起的位置。
// length	可选。子串中的字符数。必须是数值。如果省略了该参数，那么返回从 stringObject 的开始位置到结尾的字串。

// 示例：
var str="Hello world!";
var n=str.substr(2,3)

// 输出结果：llo

18、substing()

方法：提取字符串中两个指定的索引号之间的字符。

// 语法：
string.substring(from, to)

// 参数：
// from	必需。一个非负的整数，规定要提取的子串的第一个字符在 string Object 中的位置。
// to	可选。一个非负的整数，比要提取的子串的最后一个字符在 string Object 中的位置多 1。如果省略该参数，那么返回的子串会一直到字符串的结尾。

// 示例：
var str="Hello world!";
document.write(str.substring(3)+"<br>");
document.write(str.substring(3,7));

// 输出结果：lo world!	lo w

19、toLowerCase()

方法：把字符串转换为小写。

// 语法：
string.toLowerCase()

// 示例：
var str="Runoob";
document.write(str.toLowerCase());

// 输出结果：eunoob

20、toUpperCase()

方法：把字符串转换为大写。

// 语法：
string.toUpperCase()

// 示例：
var str="Runoob";
document.write(str.toUpperCase());

// 输出结果：RUNOOB

21、trim()

方法：去除字符串两边的空白。

// 语法：
string.trim()

// 示例：
var str = "       Runoob        ";
alert(str.trim());

// 输出结果：Runoob

22、toLocaleLowerCase()

方法：根据本地主机的语言环境把字符串转换为小写。

// 语法：
string.toLocaleLowerCase()

// 示例：
var str = "Runoob";
var res = str.toLocaleLowerCase();

// 输出结果：runoob

23、toLocaleUpperCase()

方法：根据本地主机的语言环境把字符串转换为大写。

// 语法：
string.toLocaleUpperCase()

// 示例：
var str = "Runoob";
var res = str.toLocaleUpperCase();

// 输出结果：RUNOOB

24、valueOf()

方法：返回某个字符串对象的原始值。

// 语法：
string.valueOf()

// 示例：
var str="Hello world!";
document.write(str.valueOf());

// 输出结果：Hello world!

25、toString()

方法：返回一个字符串。

// 语法：
string.toString()

// 示例：
var str = "Runoob";
var res = str.toString();

// 输出结果：Runoob