日期与数组与字符串的方法复习总结

一 Date对象

1 Date函数接收时间戳

​ date.getTime()​ date​ date.valueOf()//返回值 : date 的毫秒表示。返回值和方法 Date.getTime 返回的值相等。

​ Date.parse() 方法可解析一个日期时间字符串，并返回 1970/1/1 午夜距离该日期时间的毫秒数。​ 以上输出一串数字(1970年01月1日0点零分以来的毫秒数),该串数字可与随机数配合生成独特id

2 Date

1 Date对象的创建: new Date()

以下四种方法同样可以创建 Date 对象：

var d = new Date();
var d = new Date(milliseconds);
var d = new Date(dateString);
var d = new Date(year, month, day, hours, minutes, seconds, milliseconds);

2 Date 对象属性

constructor	返回对创建此对象的 Date 函数的引用。
prototype	使您有能力向对象添加属性和方法。

3 Date对象方法

方法	描述
getDate()	从 Date 对象返回一个月中的某一天 (1 ~ 31)。
getDay()	从 Date 对象返回一周中的某一天 (0 ~ 6)。
getFullYear()	从 Date 对象以四位数字返回年份。
getHours()	返回 Date 对象的小时 (0 ~ 23)。
getMilliseconds()	返回 Date 对象的毫秒(0 ~ 999)。
getMinutes()	返回 Date 对象的分钟 (0 ~ 59)。
getMonth()	从 Date 对象返回月份 (0 ~ 11)。
getSeconds()	返回 Date 对象的秒数 (0 ~ 59)。
getTime()	返回 1970 年 1 月 1 日至今的毫秒数。
getTimezoneOffset()	返回本地时间与格林威治标准时间 (GMT) 的分钟差。
getUTCDate()	根据世界时从 Date 对象返回月中的一天 (1 ~ 31)。
getUTCDay()	根据世界时从 Date 对象返回周中的一天 (0 ~ 6)。
getUTCFullYear()	根据世界时从 Date 对象返回四位数的年份。
getUTCHours()	根据世界时返回 Date 对象的小时 (0 ~ 23)。
getUTCMilliseconds()	根据世界时返回 Date 对象的毫秒(0 ~ 999)。
getUTCMinutes()	根据世界时返回 Date 对象的分钟 (0 ~ 59)。
getUTCMonth()	根据世界时从 Date 对象返回月份 (0 ~ 11)。
getUTCSeconds()	根据世界时返回 Date 对象的秒钟 (0 ~ 59)。
getYear()	已废弃。 请使用 getFullYear() 方法代替。
parse()	返回1970年1月1日午夜到指定日期（字符串）的毫秒数。
setDate()	设置 Date 对象中月的某一天 (1 ~ 31)。
setFullYear()	设置 Date 对象中的年份（四位数字）。
setHours()	设置 Date 对象中的小时 (0 ~ 23)。
setMilliseconds()	设置 Date 对象中的毫秒 (0 ~ 999)。
setMinutes()	设置 Date 对象中的分钟 (0 ~ 59)。
setMonth()	设置 Date 对象中月份 (0 ~ 11)。
setSeconds()	设置 Date 对象中的秒钟 (0 ~ 59)。
setTime()	setTime() 方法以毫秒设置 Date 对象。
setUTCDate()	根据世界时设置 Date 对象中月份的一天 (1 ~ 31)。
setUTCFullYear()	根据世界时设置 Date 对象中的年份（四位数字）。
setUTCHours()	根据世界时设置 Date 对象中的小时 (0 ~ 23)。
setUTCMilliseconds()	根据世界时设置 Date 对象中的毫秒 (0 ~ 999)。
setUTCMinutes()	根据世界时设置 Date 对象中的分钟 (0 ~ 59)。
setUTCMonth()	根据世界时设置 Date 对象中的月份 (0 ~ 11)。
setUTCSeconds()	setUTCSeconds() 方法用于根据世界时 (UTC) 设置指定时间的秒字段。
setYear()	已废弃。请使用 setFullYear() 方法代替。
toDateString()	把 Date 对象的日期部分转换为字符串。
toGMTString()	已废弃。请使用 toUTCString() 方法代替。
toISOString()	使用 ISO 标准返回字符串的日期格式。
toJSON()	以 JSON 数据格式返回日期字符串。
toLocaleDateString()	根据本地时间格式，把 Date 对象的日期部分转换为字符串。
toLocaleTimeString()	根据本地时间格式，把 Date 对象的时间部分转换为字符串。
toLocaleString()	据本地时间格式，把 Date 对象转换为字符串。
toString()	把 Date 对象转换为字符串。
toTimeString()	把 Date 对象的时间部分转换为字符串。
toUTCString()	根据世界时，把 Date 对象转换为字符串。
UTC()	根据世界时返回 1970 年 1 月 1 日 到指定日期的毫秒数。
valueOf()	返回 Date 对象的原始值。

二 数组对象

push():向数组的末尾添加一个或多个元素

定义和用法

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

注意： 新元素将添加在数组的末尾。

注意： 此方法改变数组的长度。

提示： 在数组起始位置添加元素请使用 unshift() 方法。

数组中添加新元素：

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

fruits 结果输出：

Banana,Orange,Apple,Mango,Kiwi

pop():移除最后一个数组元素

定义和用法

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

注意：此方法改变数组的长度！

提示： 移除数组第一个元素，请使用 shift() 方法。

移除最后一个数组元素

var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.pop();
fruits 结果输出：

Banana,Orange,Apple

unshift() :将新项添加到数组起始位置:

定义和用法

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

注意： 该方法将改变数组的数目。

提示: 将新项添加到数组末尾，请使用 push() 方法。

将新项添加到数组起始位置:

var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.unshift("Lemon","Pineapple");
fruits 将输出：

Lemon,Pineapple,Banana,Orange,Apple,Mango

shift():从数组中移除元素:

定义和用法

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

注意： 此方法改变数组的长度！

提示: 移除数组末尾的元素可以使用 pop() 方法。

从数组中移除元素:

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

fruits结果输出:
Orange,Apple,Mango

小练习:

         // 练习1： 将数组第一个元素移动到数组最后
        /* var arr = ['a', 'b', 'c'];
        arr.push( arr.shift() );
        console.log(arr); */
    
    
        // 练习2： 将数组最后一个元素移动到数组最前面
        var arr = ['a', 'b', 'c'];
        arr.unshift( arr.pop() );
        console.log(arr);

splice()方法:添加或删除数组中的元素：

定义和用法

splice() 方法用于添加或删除数组中的元素。

注意：这种方法会改变原始数组。

语法

array.splice(index,howmany,item1,.....,itemX)

参数 Values

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

返回值

Type	描述
Array	如果从 arrayObject 中删除了元素，则返回的是含有被删除的元素的数组。

数组中添加新元素：


var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.splice(2,0,"Lemon","Kiwi");
fruits 输出结果：

Banana,Orange,Lemon,Kiwi,Apple,Mango


实例
移除数组的第三个元素，并在数组第三个位置添加新元素:

var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.splice(2,1,"Lemon","Kiwi");
fruits 输出结果：

Banana,Orange,Lemon,Kiwi,Mango


实例
从第三个位置开始删除数组后的两个元素：

var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.splice(2,2);
fruits 输出结果：

Banana,Orange

        // 1 删除功能：例如删除数组中的bcd
        var arr = ['a', 'b', 'c', 'd', 'e'];
        /*  var result = arr.splice(1, 3);
        console.log(arr);   //输出: [a,e]
        console.log(result); //输出: [b,c,d] */

        /* var result = arr.splice(2, 1);
        console.log(arr, result); // [a,b,d,e]['c'] */
         // 2 修改功能：例如将bc修改为xyz
        /* var arr = ['a', 'b', 'c', 'd', 'e'];
        var result = arr.splice(1, 2, 'x', 'y', 'z');
        console.log(arr, result); */

        // 3 新增功能：例如，在a后添加xyz
        //   - 注意：参数1应当设置为添加后第一个元素所处的索引值
        // var arr = ['a', 'b', 'c', 'd', 'e'];
        // var result = arr.splice(1, 0, 'x', 'y', 'z');
        // console.log(arr);
        // console.log(result); // []

slice方法:从已有的数组中返回选定的元素。

定义和用法

slice() 方法可从已有的数组中返回选定的元素。

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

注意： slice() 方法不会改变原始数组。

提示： 如果是负数，则该参数规定的是从字符串的尾部开始算起的位置。也就是说，-1 指字符串的最后一个字符，-2 指倒数第二个字符，以此类推。

实例
在数组中读取元素：

var fruits = ["Banana", "Orange", "Lemon", "Apple", "Mango"];
var citrus = fruits.slice(1,3);
citrus 结果输出:

Orange,Lemon

实例
使用负值从数组中读取元素

var fruits = ["Banana", "Orange", "Lemon", "Apple", "Mango"];
var myBest = fruits.slice(-3,-1);
myBest 结果输出:

Lemon,Apple

语法

array.slice(start, end)

参数值

参数	描述
start	可选。规定从何处开始选取。如果是负数，那么它规定从数组尾部开始算起的位置。也就是说，-1 指最后一个元素，-2 指倒数第二个元素，以此类推。
end	可选。规定从何处结束选取。该参数是数组片断结束处的数组下标。如果没有指定该参数，那么切分的数组包含从 start 到数组结束的所有元素。如果这个参数是负数，那么它规定的是从数组尾部开始算起的元素。

返回值

Type	描述
Array	返回一个新的数组，包含从 start 到 end （不包括该元素）的 arrayObject 中的元素。

concat()方法

定义和用法

concat() 方法用于连接两个或多个数组。

该方法不会改变现有的数组，而仅仅会返回被连接数组的一个副本。

语法

array1.concat(array2,array3,...,arrayX)

参数

参数	描述
array2, array3, ..., arrayX	必需。该参数可以是具体的值，也可以是数组对象。可以是任意多个。

返回值

Type	描述
Array 对象	返回一个新的数组。该数组是通过把所有 arrayX 参数添加到 arrayObject 中生成的。如果要进行 concat() 操作的参数是数组，那么添加的是数组中的元素，而不是数组。

菜鸟代码:

实例
合并三个数组的值：

var hege = ["Cecilie", "Lone"];
var stale = ["Emil", "Tobias", "Linus"];
var kai = ["Robin"];
var children = hege.concat(stale,kai);
children 输出结果：

Cecilie,Lone,Emil,Tobias,Linus,Robin

案例代码

<script>
        /* var arr = [1, 2, 3];
        arr.push('a', 'b', ['x', 'y']);
        console.log(arr);
         */

        // concat() 演示
        /* var arr = [1, 2, 3];
        var result = arr.concat('a', 'b', ['x', 'y', 'z']);
        console.log(arr);
        console.log(result); // [1, 2, 3, "a", "b", "x", "y", "z"] */

        // 通常使用时，只会传入数组形式的参数，用来进行数组的元素连接
        var arr1 = [1, 2, 3];
        var arr3 = ['a', 'b', 'c'];
        var arr4 = ['x', false, true];
        var result = arr1.concat(arr3, arr4, [10, 20, 30]);
        console.log(result); 
    </script>

面试题

一道面试题：传递两个参数m，n，返回长度为m，所有元素都为n的数组，要求不能用循环。

利用函数的递归和 concat() 方法可以实现，代码如下：

function fn(m, n) {
  return m ? fn(m - 1, n).concat(n) : [];
}

indexOf()方法:

定义和用法

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

该方法将从头到尾地检索数组，看它是否含有对应的元素。开始检索的位置在数组 start 处或数组的开头（没有指定 start 参数时）。如果找到一个 item，则返回 item 的第一次出现的位置。开始位置的索引为 0。

如果在数组中没找到指定元素则返回 -1。

提示如果你想查找字符串最后出现的位置，请使用 lastIndexOf() 方法。

语法:

array.indexOf(item,start)

参数值

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

返回值:

类型	描述
Number	查找指定字符串第一次出现的位置，如果没找到匹配的字符串则返回 -1。

菜鸟代码:

实例
查找数组中的 "Apple" 元素：

var fruits = ["Banana", "Orange", "Apple", "Mango"];
var a = fruits.indexOf("Apple");
a 结果输出：

2


实例
查找数组中 "Apple" 的元素, 在数组的第四个位置开始检索：

var fruits=["Banana","Orange","Apple","Mango","Banana","Orange","Apple"];
var a = fruits.indexOf("Apple",4);
a 结果输出：

6

案例代码

<script>
        var arr = ['a', 'b', 'a', 'c', 'd', 'a', 'f', 'a', 'c', 'd', 'a', 'f', 'a', 'c', 'd', 'a', 'f', 'a', 'c', 'd', 'a', 'f'];
        /* var index = arr.indexOf('a', 0);
        console.log(index); // 0
    
        // 继续往后查找
        index = arr.indexOf('a', index   1);
        console.log(index); // 2

        index = arr.indexOf('a', index   1);
        console.log(index); // 5

        index = arr.indexOf('a', index   1);
        console.log(index); // 7 */


        // 使用while循环简化代码
        /* var index = arr.indexOf('a', 0);
        console.log(index); // 0

        // 如果后面还存在a，才需要继续重复查找
        while (arr.indexOf('a', index   1) !== -1) {
            index = arr.indexOf('a', index   1);
            console.log(index);
        } */
    
        // 使用do..while改进while的代码
        var index = -1; // 为了让do中的第一次取值为0，凑数将index初始值设置为-1
        do {
            index = arr.indexOf('a', index   1);
            console.log(index);
        } while (arr.indexOf('a', index   1) !== -1);

    </script>

reserve()方法

定义和用法

reverse() 方法用于颠倒数组中元素的顺序。

实例
颠倒数组中元素的顺序：

var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.reverse();
fruits 结果输出：

Mango,Apple,Orange,Banana

sort()方法

定义和用法

sort() 方法用于对数组的元素进行排序。

排序顺序可以是字母或数字，并按升序或降序。

默认排序顺序为按字母升序。

注意：当数字是按字母顺序排列时"40"将排在"5"前面。

使用数字排序，你必须通过一个函数作为参数来调用。

函数指定数字是按照升序还是降序排列。

注意： 这种方法会改变原始数组！。

返回值

Type	描述
Array	对数组的引用。请注意，数组在原数组上进行排序，不生成副本。

菜鸟代码:

实例
数组排序：

var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.sort();
fruits 输出结果：

Apple,Banana,Mango,Orange

实例
数字排序（数字和升序）：

var points = [40,100,1,5,25,10];
points.sort(function(a,b){return a-b});
fruits输出结果：

1,5,10,25,40,100

实例
数字排序（数字和降序）：

var points = [40,100,1,5,25,10];
points.sort(function(a,b){return b-a});
fruits输出结果：

100,40,25,10,5,1

案例代码:

        // var arr = [1, 4, 2, 6, 3, 12, 23, 22, 18, 9];
        // 如果希望对数值数组正常排序，需要设置参数：
        //   - 升序参数：
        //     -  function (a, b) { return a - b }
        //   - 降序参数
        //     - function (a, b) { return b - a }
        /* arr.sort(function (a, b) {
            return b - a;
        });
        console.log(arr); */

对sort()实现方式的分析:

 <script>
        // var arr = [1, 4, 2, 6, 3, 12, 23, 22, 18, 9];
        // 如果希望对数值数组正常排序，需要设置参数：
        //   - 升序参数：
        //     -  function (a, b) { return a - b }
        //   - 降序参数
        //     - function (a, b) { return b - a }
        

        // 通过冒泡排序的实现分析参数的设置方式：
        function mySort (arr, fn) {
            for (var i = 0; i < arr.length - 1; i  ) {
                for (var j = 0; j < arr.length - i - 1; j  ) {
                    /*
                        升序格式:
                            arr[j] > arr[j   1]
                            arr[j] - arr[j   1] > 0
                        降序格式:
                            arr[j] < arr[j   1]
                            arr[j   1] > arr[j]
                            arr[j   1] - arr[j] > 0
                    */
                    
                    if (fn(arr[j], arr[j   1]) > 0) {
                        var temp = arr[j];
                        arr[j] = arr[j   1];
                        arr[j   1] = temp;
                    }
                }
            }
        }

        var arr = [1, 4, 2, 6, 3, 12, 23, 22, 18, 9];
        // 自带的方法可以写成arr.sort() 我们的mySort不是自带的，就不能那么写
         mySort(arr, function (a, b) {
            return b - a;
        });
         
        /* mySort(arr, function (a, b) {
            return b - a;
        }); */
        
        console.log(arr);
    
    
    </script>

toString()

定义和用法

toString() 方法可把数组转换为字符串，并返回结果。

注意： 数组中的元素之间用逗号分隔。

实例
将数组转换为字符串：

var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.toString();
fruits将输出：

Banana,Orange,Apple,Mango

join()

定义和用法

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

元素是通过指定的分隔符进行分隔的。

语法:

array.join(separator)

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

返回值

类型	描述
String	返回一个字符串。该字符串是通过把 arrayObject 的每个元素转换为字符串，然后把这些字符串连接起来，在两个元素之间插入 separator 字符串而生成的。

菜鸟代码

实例
把数组中的所有元素转换为一个字符串：

var fruits = ["Banana", "Orange", "Apple", "Mango"];
var energy = fruits.join();
energy输出结果：

Banana,Orange,Apple,Mango

实例
使用不同的分隔符：

var fruits = ["Banana", "Orange", "Apple", "Mango"];
var energy = fruits.join(" and ");
energy 结果输出：

Banana and Orange and Apple and Mango

案例代码

        // join() 
        //  - 参数：连接符，默认为逗号,连接
        //  - 返回值：连接后的字符串
        var arr = [1, 2, 3];
        console.log( arr.join() ); // '1,2,3'
        console.log( arr.join('-') ); // '1-2-3'
        console.log( arr.join('abc') ); // '1abc2abc3'
        console.log( arr.join('') ); // '123'

三 字符串的操作方法

charAt()

定义和用法

charAt() 方法可返回指定位置的字符。

第一个字符位置为 0, 第二个字符位置为 1,以此类推.

菜鸟代码

实例
返回字符串中的第三个字符:

var str = "HELLO WORLD";
var n = str.charAt(2)
n输出结果:

L


实例
返回字符串中的最后一个字符：

var str = "HELLO WORLD";
var n = str.charAt(str.length-1);
n 返回值:

D

案例代码:

<script>
        // 字符串也可以根据索引操作

        // 方式1： []操作方式
        var str = 'abcdefg';
        // console.log(str[1]); // 'b'
        // console.log(str[4]); // 'e'

        /* str[0] = 'z';
        console.log(str);  */// 'abcdefg' 无法修改，体现了字符串的不可变性
    
        // 遍历字符串
        /* for (var i = 0; i < str.length; i  ) {
            console.log(str[i]);
        } */
        
        // 方式2：字符串.charAt(索引值)
        // console.log( str.charAt(2) ); // 'c'
        for (var i = 0; i < str.length; i  ) {
            console.log(str.charAt(i));
        }
    
    
    </script>

slice()

定义和用法

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

使用 start（包含） 和 end（不包含） 参数来指定字符串提取的部分。

字符串中第一个字符位置为 0, 第二个字符位置为 1, 以此类推。

提示： 如果是负数，则该参数规定的是从字符串的尾部开始算起的位置。也就是说，-1 指字符串的最后一个字符，-2 指倒数第二个字符，以此类推。

用法与数组的slice()方法相似

        // 1 slice()
        /* var str = 'abcdefg';
        console.log(str.slice(1, 4));
        // console.log(str.slice());
        console.log(str); */




实例
提取所有字符串:

var str="Hello world!";
var n=str.slice(0);
以上实例输出结果：

Hello world!
    
 实例
从字符串的第3个位置提取字符串片段:

var str="Hello world!";
var n=str.slice(3);
以上实例输出结果：

lo world!
    
实例
从字符串的第3个位置到第8个位置直接的字符串片段:

var str="Hello world!";
var n=str.slice(3,8);
以上实例输出结果：

lo wo


实例

只提取第1个字符:

var str="Hello world!";
var n=str.slice(0,1);
以上实例输出结果：

H


实例
提取最后一个字符:

var str="Hello world!";
var n=str.slice(-1);
以上实例输出结果：

!

substring()

与slice()作用较为相似,,但不包括结束处的字符。类似数学上的[ ) 这样的区间

定义和用法

substring() 方法用于提取字符串中介于两个指定下标之间的字符。

substring() 方法返回的子串包括 开始 处的字符，但不包括 结束 处的字符。

语法:

string.substring(from, to)

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

        // 2 substring() 使用方式与前面的slice一样
        /* var str = 'abcdefg';
        console.log(str.substring(1, 4));
        console.log(str.substring());
        console.log(str); */

substr()

定义和用法

substr() 方法可在字符串中抽取从 开始 下标开始的指定数目的字符。

提示： substr() 的参数指定的是子串的开始位置和长度，因此它可以替代 substring() 和 slice() 来使用。

注意： substr() 方法不会改变源字符串。

语法

string.substr(start,length)

参数	描述
start	必需。要抽取的子串的起始下标。必须是数值。如果是负数，那么该参数声明从字符串的尾部开始算起的位置。也就是说，-1 指字符串中最后一个字符，-2 指倒数第二个字符，以此类推。
length	可选。子串中的字符数。必须是数值。如果省略了该参数，那么返回从 stringObject 的开始位置到结尾的字串。

返回值

类型	描述
String	返回一串包含文本提取部分的新字符串

菜鸟代码

实例
抽取指定数目的字符：

var str="Hello world!";
var n=str.substr(2,3)
n 输出结果:

llo

实例
在本例中，我们将使用 substr() 从字符串第二个位置中提取一些字符：
var str="Hello world!";
var n=str.substr(2)
n 输出结果:

llo world!

提一笔

slice()和substring()方法 括号里的参数都是(start,end),即开始时的数组下标到结束时的数组下标,而substr()方法 括号里的参数是(start,length),即开始目标的下标和截取字符长度(截取几个字符写多少),所以相对爱建substr表较好用

indexOf()

定义和用法

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

如果没有找到匹配的字符串则返回 -1。

注意： indexOf() 方法区分大小写。

提示： 同样你可以查看类似方法 lastIndexOf() 。

语法:

string.indexOf(searchvalue,start)

参数值

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

返回值:

类型	描述
Number	查找指定字符串第一次出现的位置，如果没找到匹配的字符串则返回 -1。

菜鸟代码:

实例
查找字符串 "welcome":

var str="Hello world, welcome to the universe.";
var n=str.indexOf("welcome");
n 输出结果:

13


实例
在字符串查找字符 "e" 第一次出现的位置:

var str="Hello world, welcome to the universe.";
var n=str.indexOf("e");
n 输出结果:

1

实例
在字符串第五个位置开始查找字符 "e" 第一次出现的位置:

var str="Hello world, welcome to the universe.";
var n=str.indexOf("e",5);
n 输出结果:

14

案例代码

    <script>
        // var str = 'ab123c321abc213abc123dwabda';
        /* console.log( str.indexOf('a') ); // 0
        console.log( str.indexOf('a', 1) ); // 9
        console.log( str.indexOf('a', 10) ); // 15
        */
        // 与数组一样，可以通过while和do..while循环改进

        // 注意点：
        //  1 检索字符串中的多个字符组成部分, 返回的是首字符的索引
        /* var str = 'abc123c321abc213abc123dwada';
        console.log(str.indexOf('abc')); // 0
        console.log(str.indexOf('abc', 1)); // 10 */
        
        //  2 如果使用indexOf检索空字符串''，一定返回0
        var str = 'abcdefg';
        console.log(str.indexOf('')); // 0
    </script>

toUpperCase()

        /* var str = 'abcdefgABC123';
        console.log(str.toUpperCase());
        console.log(str); */

toLowerCase()

        /* var str = 'ABECDEabc123';
        console.log(str.toLowerCase());
        console.log(str); */

replace()

定义和用法

replace() 方法用于在字符串中用一些字符替换另一些字符,或替换一个与正则表达式匹配的子串。

该方法不会改变原始字符串。

语法

string.replace(searchvalue,newvalue)

参数

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

返回值

String	一个新的字符串，是用 replacement 替换了 regexp 的第一次匹配或所有匹配之后得到的。

实例
在本例中，我们将执行一次替换，当第一个 "Microsoft" 被找到，它就被替换为 "Runoob"：

var str="Visit Microsoft! Visit Microsoft!";
var n=str.replace("Microsoft","Runoob");
n 输出结果:

Visit Runoob!Visit Microsoft!
    
实例
执行一个全局替换:

var str="Mr Blue has a blue house and a blue car";
var n=str.replace(/blue/g,"red");
n 输出结果:

Mr Blue has a red house and a red car


实例
执行一个全局替换, 忽略大小写:

var str="Mr Blue has a blue house and a blue car";
var n=str.replace(/blue/gi, "red");
n 输出结果:

Mr red has a red house and a red car

/*
因为replace替换方法一次只能替换一次,所以要在文本中进行所有替换就需要循环了(看案例代码),但循环也是比较麻烦的,所以我们可以用正则表达式来进行全局替换

这里补充一下正则表达式replace替换
/表达式/[修饰符]
g:全局匹配
i:忽略大小写
gi:全局 忽略
*/
//这个可以应用于屏蔽敏感词

案例代码

<script>
        var str = 'a-b-c-d';
        // 例如希望将str中的-换成|
        //  - 注意只能替换从左往右找到的第一段内容
        /* console.log(str.replace('-', '|'));
        console.log(str); */

        // console.log(str.replace('-', '|'));
        // console.log(str.replace('-', '|').replace('-', '|').replace('-', '|'));
    
        // 通过while循环替换字符串中的所有-
        while (str.indexOf('-') !== -1) {
            // 进行替换操作即可
            str = str.replace('-', '|');
        }
        console.log(str);

    </script>

split()

定义和用法

split() 方法用于把一个字符串分割成字符串数组。

提示： 如果把空字符串 ("") 用作 separator，那么 stringObject 中的每个字符之间都会被分割。

注意： split() 方法不改变原始字符串。

语法

string.split(separator,limit)

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

返回值

类型	描述
Array	一个字符串数组。该数组是通过在 separator 指定的边界处将字符串 string Object 分割成子串创建的。返回的数组中的字串不包括 separator 自身。

菜鸟代码

实例
省略分割参数：

var str="How are you doing today?";
var n=str.split();
n 输出数组值得结果:

How are you doing today?
    
    
 实例
分割每个字符，包括空格:

var str="How are you doing today?";
var n=str.split("");
n 输出数组值得结果:

H,o,w, ,a,r,e, ,y,o,u, ,d,o,i,n,g, ,t,o,d,a,y,?
    
    
    
    
 实例
使用 limit 参数:

var str="How are you doing today?";
var n=str.split(" ",3);
n 将输出3个数组的值:

How,are,you


实例
使用一个字符作为分隔符:

var str="How are you doing today?";
var n=str.split("o");
n 输出数组值得结果:

H,w are y,u d,ing t,day?

案例代码

    <script>
        // var str = 'a-b-c-d-e';
        // console.log(str.split('-'));
        // console.log(str.split()); // 不传参数没有意义
        // console.log(str.split('')); // 传入空字符串，将每个字符分隔

        // 与数组的join方法结合使用：
        // 1 替换字符串中的部分内容
        var str = 'a-b-c-d-e'; // 将字符串中的-替换为|
        console.log(str.split('-'));
        console.log(str.split('-').join('|'));


        // 2 删除字符串中的部分内容
        /* var str = 'a-b-c-d-e'; // 将字符串中的-删除
           console.log(str.split('-').join('')); */
    </script>

trim()

定义和用法

trim() 方法用于删除字符串的头尾空格。

trim() 方法不会改变原始字符串。

语法

string.trim()

返回值

类型	描述
String	返回移除头尾空格的字符串。

菜鸟代码

实例
去除字符串的头尾空格:

var str = "       Runoob        ";
alert(str.trim());
输出结果:

Runoob

案例代码

        var str = '  jack  ';
        console.log(str.trim());
        console.log(str);