【转】JS内置对象方法

String内置对象的方法

1. concat()

concat() – 将两个或多个字符的文本组合起来，返回一个新的字符串

var str = "Hello";
var out = str.concat(" World","!");
console.log(str); //Hello
console.log(out); //Hello World!

2. charAt()

charAt() – 返回指定位置的字符

var str = "HelloString";
var out = str.charAt(1);
console.log(out); //e

3. charCodeAt()

charCodeAt() – 返回在指定的位置的字符的 Unicode 编码

var str = "HelloString";
var out = str.charCodeAt(5);
console.log(out); //83

4. indexOf()

indexOf(searchvalue,fromindex) – 返回字符串中一个子串第一处出现的索引，如果没有匹配项，返回 -1 。

fromindex是可选的整数参数。规定在字符串中开始检索的位置。它的合法取值是 0 到 stringObject.length - 1。

如省略该参数，则将从字符串的首字符开始检索,此时indexOf()跟search()方法类似。

var str = "HelloStringend";
console.log(str.indexOf("e")); //1
console.log(str.indexOf("e",2)); //11

5. lastIndexOf()

lastIndexOf(searchvalue,fromindex) – 返回字符串中一个子串最后一处出现的索引，如果没有匹配项，返回 -1 。

如果在 stringObject 中的 fromindex 位置之前存在 searchvalue，则返回的是出现的最后一个 searchvalue 的位置。

var str = "HelloString";
console.log(str.lastIndexOf("l")); //3
console.log(str.lastIndexOf("l", 1)); //-1
console.log(str.lastIndexOf("l", 2)); //2
console.log(str.lastIndexOf("l", 3)); //3

6.substring()

substring(start,end) – 返回一个新的字符串,包括 start 处的字符,但不包括 end 处的字符,其长度为 end 减 start

substring是以两个参数中较小一个作为起始位置，较大的参数作为结束位置。

注意：如果参数是负数，substring则会将负参数都直接转换为0，如果仅有一个参数，则从start开始到末尾。

var str = "HelloExample";
console.log(str); //HelloExample
console.log(str.substring(1, 3)); //el
console.log(str.substring(3, 1)); //el
console.log(str.substring(2)); //lloExample
console.log(str.substring(-1)); //HelloExample
console.log(str.substring(-1, -3)); //空字符串
console.log(str.substring(-1, 5)); //Hello

7. substr()

substr(start [,length]) – 返回一个新的字符串,从起始索引号提取字符串中指定数目的字符。

如果仅有一个参数，则从start开始到末尾。

当接收的参数是负数时,substr是将第一个参数与字符串长度相加后的结果作为第一个参数

var str = "HelloExample";
console.log(str); //HelloExample
console.log(str.substr(1, 3)); //ell
console.log(str.substr(2, -1)); //空字符串
console.log(str.substr(1)); //elloExample
console.log(str.substr(-4, 2)); //mp
console.log(str.substr(-3)); //ple

8. slice()

slice(start,end) 返回一个新的字符串,包括 start 处的字符,但不包括 end 处的字符,其长度为 end 减 start

当接收的参数是负数时，slice会将它字符串的长度与对应的负数相加，结果作为参数。如果仅有一个参数，则从start开始到末尾

var str = "HelloExample";
console.log(str); //HelloExample
console.log(str.slice(1, 3)); //el
console.log(str.slice(2)); //lloExmaple
console.log(str.slice(3, 1)); //空字符串
console.log(str.slice(-4, -1)); //mpl
console.log(str.slice(-4, 0)); //空字符串
console.log(str.slice(-1, -4)); //空字符串
console.log(str.slice(1, -4)); //elloExa

9. toLowerCase()

toLowerCase() – 将整个字符串转成小写字母。

注意：toUpperCase() – 将整个字符串转成大写字母。

var str = "How Are you";
console.log(str.toLowerCase()); //how are you
console.log(str.toUpperCase()); //HOW ARE YOU

10. split()

split(separator,howmany) – 返回一个字符串数组。该数组是通过在 separator 指定的边界处将字符串 stringObject 分割成子串创建的。返回的数组中的字串不包括 separator 自身

var str = "How are you doing today";
console.log(str.split(" ")); //["How", "are", "you", "doing", "today"]
console.log(str); //How are you doing today
console.log(str.split("")); //["H", "o", "w", " ", "a", "r", "e", " ", "y", "o", "u", " ", "d", "o", "i", "n", "g", " ", "t", "o", "d", "a", "y"]
console.log(str.split("", 3)); //["H", "o", "w"]
console.log(str.split("a")); //["How ", "re you doing tod", "y"]
console.log(str.split("good")); //["How are you doing today"]
var str = "a_db-c(d+e";
console.log(str.split(/[^a-z]/i)); //["a", "db", "c", "d", "e"]

11. match()

match(searchvalue) 或 match(regexp)检查一个字符串是否匹配一个正则表达式。返回存放匹配结果的数组。

match() 方法将检索字符串 stringObject，以找到一个或多个与 regexp 匹配的文本。这个方法的行为在很大程度上有赖于 regexp 是否具有标志 g。

如果 regexp 没有标志 g，那么 match() 方法就只能在 stringObject 中执行一次匹配。如果没有找到任何匹配的文本， match() 将返回 null。否则，它将返回一个数组，其中存放了与它找到的匹配文本有关的信息。该数组的第 0 个元素存放的是匹配文本，而其余的元素存放的是与正则表达式的子表达式匹配的文本。除了这些常规的数组元素之外，返回的数组还含有两个对象属性。index 属性声明的是匹配文本的起始字符在 stringObject 中的位置，input 属性声明的是对 stringObject 的引用。

如果 regexp 具有标志 g，则 match() 方法将执行全局检索，找到 stringObject 中的所有匹配子字符串。若没有找到任何匹配的子串，则返回 null。如果找到了一个或多个匹配子串，则返回一个数组。不过全局匹配返回的数组的内容与前者大不相同，它的数组元素中存放的是 stringObject 中所有的匹配子串，而且也没有 index 属性或 input 属性。

var str = "Hello world! Hello";
console.log(str.match("lo")); //["lo"] { index: 3, input: "Hello world! Hello" }
console.log(str.match("world")); //["world"] { index: 6, input: "Hello world! Hello" }
console.log(str.match("world").index); //6
console.log(str.match(/Hello/g)); //["Hello", "Hello"]
console.log(str.match("World")); //null
var str = "1 plus 2 equal 3";
console.log(str.match(/\d+/g)); //["1", "2", "3"]

12. replace()

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

stringObject.replace(regexp/substr,replacement),返回一个新的字符串，是用 replacement 替换了 regexp 的第一次匹配或所有匹配之后得到的。

replacement 可以是字符串，也可以是函数。如果它是字符串，那么每个匹配都将由字符串替换。但是 replacement 中的 $ 字符具有特定的含义，它说明从模式匹配得到的字符串将用于替换。

var str = "Visit HangZhou";
console.log(str); //Visit HangZhou
console.log(str.replace(/Hang/g, "Su")); //Visit SuZhou
var str = "1 plus 2 equal 3";
console.log(str); //1 plus 2 equal 3
console.log(str.replace(/(\d)/g, "*")); //* plus * equal *

var str = "as An angle";
console.log(str.replace(/a/, "b")); //bs An angle
console.log(str.replace(/a/g, "b")); //bs An bngle
console.log(str.replace(/a/gi, "b")); //bs bn angle

var str = "Karl,John";
console.log(str.replace(/(\w+)\s*,\s*(\w+)/, "$2,$1")); //John,Karl

var str = '"ab", "b"';
console.log(str.replace(/"([^"]*)"/g, "'$1'")); //'ab', 'b'

var str = "aaa bbb ccc";
console.log(str.replace(/\b\w+\b/g, function (w) {
return w.substring(0, 1).toUpperCase() + w.substring(1);
})); //Aaa Bbb Ccc

13. search()

search() – 执行一个正则表达式匹配查找。如果查找成功，返回字符串中匹配的索引值。否则返回 -1 。

stringObject.search(regexp) 返回stringObject 中第一个与 regexp 相匹配的子串的起始位置。

此方法跟indexOf类似。此方法会忽略g标识

var str = "Visit HangZhou";
console.log(str) //Visit HangZhou
console.log(str.search(/Hang/)); //6
console.log(str.search(/hang/)); //-1
console.log(str.search(/hang/i)); //6
var str = "1 plus 2 equal 3";
console.log(str) //1 plus 2 equal 3
console.log(str.search(/\d/g)); //0

数组内置对象的方法

1. join()

join()——将数组中的所有元素转化为字符串并连接在一起，返回最后生成的字符串。不修改原始数组

let a = [1, 2, 3];
a.join();               // => "1,2,3"，默认使用","隔开元素
a.join("&");            // => "1&2&3"，指定分隔符

2. reverse()

reverse()——将数组中的元素逆序，返回逆序后的数组。修改原始数组

let a = [1, 2, 3];
a.reverse().join();     // => "3,2,1"，此时的a是[3, 2, 1]

3. sort()

sort()——将数组元素进行排序，返回排序后的数组。默认以字母表顺序排序。修改原始数组

let a = new Array("banana", "cherrry", "apple");
a.sort();
let s = a.join(", ");   // => "apple, banana, cherrry"

4. concat()

concat()——创建并返回一个新数组。不修改原始数组

let a = [1,2,3];
a.concat(4, 5);         // 返回[1,2,3,4,5]
a.concat([4,5]);        // 返回[1,2,3,4,5]
a.concat([4,5],[6,7]);  // 返回[1,2,3,4,5,6,7]
a.concat(4, [5, [6,7]]);// 返回[1,2,3,4,5,[6,7]]
a.join();               // "1,2,3"，原始值不发生改变

5. slice()

slice()——对数组进行分离，并返回一个子数组。不修改原始数组

• 第1个参数表示起始索引
• 第2个参数表示结束索引(返回数组不包含结束索引对应的元素值)
  
  如果没有第2个参数，则表示取值到最后一个索引。正值表示正向索引，负值表示反向索引

let a = [1,2,3,4,5];
a.slice(0, 3);          // 返回[1,2,3]
a.slice(3);             // 返回[4,5]
a.slice(-3, -1);        // 返回[3,4]，反向索引，从倒数第3个到倒数第1个元素

6. splice()

splice()——从数组中删除和插入一些元素。修改原始数组

• 前2个参数指定了要删除的数组元素

  • 第1个参数表示需要删除元素的起始索引值
  • 第2个参数表示需要删除的个数
    
    如果省略则表示删除起始索引后的所有元素

• 后面的参数指定需要插入的元素

let a = [1,2,3,4,5,6,7,8];
a.splice(4);                // 返回[5,6,7,8]，a是[1,2,3,4]
a.splice(1,2);              // 返回[2,3]，a是[1,4]
a.splice(1,1);              // 返回[4]，a是[1]

let b = [1,2,3,4,5];
a.splice(2,0, "a", "b");    // 返回[]，a是[1,2, "a","b", 3,4,5]
a.splice(2,2, [1,2], 3);    // 返回["a", "b"]，a是[1,2, [1,2],3, 3,4,5]

7.push(),pop()

push()——在数组的尾部添加一个或多个元素，并返回数组新的长度，修改原始数组

pop()——在数组的尾部删除一个元素，并返回弹出的元素值，修改原始数组

let stack = [];
stack.push(1,2);    // stack:[1,2]，返回2
stack.push([1,2]);  // stack:[1,2, [1,2]]，返回3
stack.pop();        // stack:[1,2]，返回[1,2]

8. shift(),unshift()

unshift()——在数组的头部添加，返回新的数组长度，修改原始数组

shift()——在数组的头部删除，返回删除的数组元素，修改原始数组

let a = [1];
a.unshift(2);           // a:[2, 1]，返回2
a.unshift(3, [4,5]);    // a:[3, [4,5], 2,1]，返回4。
a.shift();              // a:[[4,5], 2, 1]，返回3

9. toString()

toString()——返回一个字符串

[1,2,3].toString();         // "1,2,3"
[1, [2, "c"]].toString();   // "1,2,c"

10. forEach()

forEach()——方法从头至尾遍历数组，为每个元素调用指定的函数

• forEach()没有像for循环中使用的相应的break语句，如果要提前终止，可以做放到try/catch中处理

let data = [1,2,3,4,5];
let sum  = 0;
data.forEach(function(value) { sum += value;} );
sum;

11. map()

map()——方法为数组的每个元素调用指定的函数，并返回一个新数组

• 注意：map()返回的是新数组，它不修改原始数组

a = [1,2,3];
b = a.map(function(x) {return x*x; });  // b是[1,4,9]

12. filter()

filter()——方法为数组的每个元素调用指定的函数，并返回筛选出的新数组，some()就会返回true；只有当所有调用都是false时，some()才返回false

a = [5,4,3,2,1];
smallvalues = a.filter(function(x) { return x < 3; });
// smallvalues是[2, 1]

13. every(),some()

every()——方法为数组的每个元素调用指定的函数，并返回true或false。当有一个调用返回false时，every()就会返回false；只有当所有调用都是true时，every()才返回true

some()——方法为数组的每个元素调用指定的函数，并返回true或false。当有一个调用返回true时，some()就会返回true；只有当所有调用都是false时，some()才返回false

let a = [1,2,3,4,5];
a.every(function(x) { return x < 10; });    // => true，所有的值<10
a.every(function(x) { return x % 2 === 0}); // => false，不是所有的值都是偶数
a.some(function(x) { return x % 2 === 0; }) // => true，a含有偶数值

14. reduce()

reduce()——对数组的元素对调用指定的函数，并返回最终生成的单个值

• 第1个参数指定调用的函数
• 第2个参数为可选参数，指定传递给函数的初始值，当不指定值时，使用数组的第1个元素作为初始值

let a   = [1,2,3,4,5];
let sum = a.reduce(function(x,y) { return x+y; }, 0);       //15
let max = a.reduce(function(x,y) { return (x>y)?x:y; });    // 5

15. indexOf()

indexOf()——搜索整个数组中给定值的元素，返回找到的第1个元素的索引，如果找不到，则返回-1

• 第1个参数为需要搜索的值
• 第2个参数是可选的，指定开始搜索的索引位置

let a = [0,1,2,1,0];
a.indexOf(1);           // =>1: a[1] = 1
a.lastIndexOf(1);       // =>3: a[3] = 1
a.indexOf(3);           // =>-1: a中没有值为3的元素

16. isArray()

Array.isArray()——判断一个对象是否是数组

Array.isArray([]);      // true
Array.isArray({});      // false

Math内置对象的方法

abs(x) —— 返回 x 的绝对值

round(x) —— 返回 x 四舍五入后的值

sqrt(x) —— 返回 x 的平方根

ceil(x) —— 返回大于等于 x 的最小整数

floor(x) —— 返回小于等于 x 的最大整数

max(a, b) —— 返回 a, b 中较大的数

min(a, b) —— 返回 a, b 中较小的数

random() —— 返回大于 0 小于 1 的一个随机数

转载:

String

Math

数组