JS对象常用方法总结

jiezi

5 年前

返回在指定位置的字符

var str = 'nihaome wozhendexiangxeuhaoqianduan'
var str2 = str.charAt(4); 字符串的下标是从 1 开始的, 所以返回 o
var str3 = str.charAt(25);  25 位置是 a;
var str4 = str.charAt(5,26);  传入两个参数，不会报错，但是第二个参数默认无效，所以返回的是位置 5 的字符 m

返回咋指定位置的字符的 Unicode 编码

var str = "llinihao mezaigama";
var str2 = str.charCodeAt(5);  位置 5 的字符是 h，h 的 Unicode 编码是 104
var str3 = str.charCodeAt(3);
console.log(str3); // 110
console.log(str2); // 104

连接字符串

var str1 = "lixiaoqi";
var str2 = 'zaijian';
console.log(str2.concat(str1)); 把 str1 连接到 str2 上 
// zaijianlixiaoqi

检索字符串，返回的是字符在字符串的下标

var str1 = "lixiaoqi";
var num1 = str1.indexOf('o');  检索字符串，返回的是字符在字符串的下标
字符串的下标是从 0 开始计数
var num2 = str1.indexOf('lllll');  没有找到匹配的值，返回 -1
var num3 = str1.indexOf('ni');  没有找到匹配的值，返回 -1
console.log(num1); // 5
console.log(num2); // -1
console.log(num3); // -1

在字符串内检索指定的值或找到一个或多个正则表达式的匹配，返回的是值而不是值的位置。

var str1 = "lixiaoqi";
var str2 = str1.match('iao');  检索字符串，返回的是字符
var str3 = str1.match('lll');  没有指定的字符，返回的是 null

替换匹配的字符串

var str1 = "nihaome";
var str2 = "lixiaoqi";
var str3 = str1.replace(str1.match('hao'),str2.match('lixi'));
找到 str1 的 hao，找到 str2 的 lixi，用 str2 替换掉 str1
console.log(str3); // nilixime

检索与字符串匹配的子串，返回的是地址

var str1 = "lixiaoqi nihaoya zaiganma";
var str2 = "nihaoya";
var str3 = "wobuzai";
var num1 = str1.search(str2); 返回的是第一个字符所在的位置
var num2 = str1.search(str3); 未检测到返回 -1
console.log(num1); // 9
console.log(num2); // -1

把字符分割成数组

var str1 = "nihao-zaijian-dajiahao";
console.log(str1.split('')); // ["n","i","h","a","o","z","a" ...]
var str2 = str1.split('-');
console.log(str2); // ["nihao","zaijian","dajiahao"]
console.log(str1); 原字符串不变  //  nihao-zaijian-dajiahao

提取字符串片段，并在新的字符串中返回被提取的部分

var str1 = 'nihaoya wobuhaoya'
console.log(str1.slice(4,9)); 4 位置开始，到 9 的前一个位置结束
console.log(str1.slice(2,14)); start 位置开始，end 前一个位置结束
console.log(str1); 原字符串不变
console.log(str1.slice(-1,0));  返回的是空字符串
console.log(str1.slice(30,100));  长度超过字符串的长度，返回空字符串
console.log(str1.slice(-1,10)); 返回的是空字符串

把字符串转换成小写

var str = "NIHAOME WOHENHAOnizaiganmane";
console.log(str.toLocaleLowerCase()); // nihaome wohenhaonizaiganmane
var str1 = str.toLocaleLowerCase(); 
console.log(str1);  // nihaome wohenhaonizaiganmane
console.log(str); 原字符串不变  // NIHAOME WOHENHAOnizaiganmane

把字符串转换成小写

var str = "deawwWWEzaiganmane";
console.log(str.toLowerCase()); // deawwwwezaiganmane
var str1 = str.toLowerCase();
console.log(str1);  // deawwwwezaiganmane
console.log(str); 原字符串不变

把字符串准换成大写

var str = "deawwWWEzaiganmane";
console.log(str.toLocaleUpperCase()); // DEAWWWWEZAIGANMANeE
var str1 = str.toLocaleUpperCase();
console.log(str1);  // DEAWWWWEZAIGANMANeE
console.log(str); 原字符串不变

从起始索引号提取字符串中指定书目的字符

var str = "nihaoya wohenhao dajiahao"
var str3 = str.substr(3,19); 字符串中空格不占位置，从 3 开始，到 19 结束
console.log(str3); // aoya wohenhao dajia

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

var str = "nihaoya wohenhao dajiahao"
var str3 = str.substring(3,19); 字符串中空格占位置，从 3 开始，到 18 结束
var str4 = str.substr(3,19); 空格不占位。从 3 开始到 19 结束

返回从原数组中指定开始下表到结束下表之间的项组成的新数组（原数组不变）

var arr = [1,2,3,4,5,6,7,8];
var arr1 = arr.slice(2,6);
console.log(arr1); // ["3","4","5","6"]
数组下表从 0 开始，从 2 开始，到 6 的前一个位置结束
var arr3 = arr.slice(4); 从 4 开始到结束
console.log(arr3); // ["5","6","7","8"]

var arr = [1,2,3,4,5];
var arr1 = arr.slice(2,3); 实际得到的新数组的项数是 end-strat；console.log(arr1); // [3]
var arr2 = arr.slice(1,5);
console.log(arr2); // [2,3,4,5]
console.log(arr); // [1,2,3,4,5]
插入：3 个参数，起始位置，删除的项数，插入的项。替换，任意参数，起始位置，删除的项数，插入任意数量的项数

删除数组的最后一个元素，减少数组的长度，返回被删除的值

var arr = [1,2,3,4,5];
console.log(arr.length); // 5
var arr1 = arr.pop(); 
console.log(arr1); //5
console.log(arr.length);  //4

将参数添加到数组的最后，返回新数组的长度

var arr = [1,2,3,4,5];
console.log(arr.length);  // 5
var num = arr.push(6,7,8); 
console.log(num); 返回的是新数组的长度 // 8
console.log(arr); 原数组被改变成新数组 // [1,2,3,4,5,6,7,8];

删除数组的第一个参数，数组的长度减 1，无参

var arr = [1,2,3,4,5];
console.log(arr.length); // 5
var arr1 = arr.shift(); 
console.log(arr1); 返回的是删除的数组的值  // 1
console.log(arr); 原数组被改变成新数组 // [2,3,4,5];

像数组的开头添加一个或更多的元素，并返回新的长度。（参数不限）

var arr = [1,2,3,4,5];
console.log(arr.length); // 5
var arr1 = arr.unshift(2,4,5,{name:'liqi'}); 
console.log(arr1); 返回的是新数组的长度 // 9
console.log(arr); 原数组被改变成新数组 // [2,4,5,{name: liqi},1,2,3,4,5];

按指定的参数对数组进行排序，返回的值是经过排序后的数组（无参，函数）

var arr = [1,'q',3,6,2,'a',9];
console.log(arr); 原数组
var arr1 = arr.sort();
console.log(arr1); 返回的是排序后的数组 // [1,2,3,6,9,"a","q"];
console.log(arr); 原数组变成新数组  // [1,2,3,6,9,"a","q"];

把两个字符串连接起来，返回的值是一个副本（参数不限）

var arr1 = [1,'q',3,6,2,'a',9];
var arr2 = [{name:'niho'},1,4];
console.log(arr1.concat(3,arr1)); 新创建一个数组，原数组不变 // [1,"q",3,6,2,"a",9,3,1,"q",3,6,2,"a",9]
console.log(arr1); // [[1,"q",3,6,2,"a",9]
console.log(arr2); 原数组不变  //[{name:'niho'},1,4];

从数组的开头向后查找，接受两个参数，要查找的项和查找起点的位置索引

var arr = [1,2,3,4,5,6,78];
var num = arr.indexOf(78,3); 查找 78 所在的位置
console.log(num); 返回的项的索引 // 6
var num1 = arr.indexOf(3,1);
console.log(num1); // 2
var num2 = arr.indexOf(2);
console.log(num2); // 1
console.log(arr); // [1,2,3,4,5,6,78];

将数组的元素组成一个字符串，以 separator（分割器）

var arr1 = [1,'q',3,6,2,'a',9];
var arr2 = arr1.join(','); 以逗号分隔
var arr3 = arr1.join(''); 以空格分隔
console.log(arr1); 原数组不变
console.log(arr2); // 1,q,3,6,2,a,9
console.log(arr3); // 1q362a9

对数组的每个元素执行一次提供的函数。

var arr1 = ['a', 'b', 'c'];
arr1.forEach(function(element) {console.log(element); // a b c
});

对数组的每一项运行给定的函数，返回没戏函数调用的结果组成的数组

var arr = [1, 4, 9, 16];
const map1 = arr.map(x => x * 2); // 对数组的每项 *2
console.log(map1); // 2 8 18 32

遍历数组

var arr = [1, 4, 9, 16];
for (var i = 0; i < arr.length; i++){console.log(arr[i]); // 1 4 9 16
}

every 是所有函数的每个回调都返回 true 的时候才会返回 true，当遇到 false 的时候终止执行，返回 false。
some 函数是存在有一个函数返回 true 的时候终止执行并返回 true，否则返回 false。

// every 方法
var arr = [1,6,8,-2,-5,7,-4]
var isPositive = arr.every(function(value){return value > 0;})
console.log(isPositive) // false

//some 方法
var arr = [1,6,8,-2,-5,7,-4]
var isPositive = arr.some(function(value){return value > 0;})
console.log(isPositive) // true

这是 Array 对象的一个静态函数，用来判断一个对象是不是数组

var arr = [3,4,5]
console.log(Array.isArray(arr)); // true
// ES3 的判断方法
console.log(typeof arr); // object
console.log(arr.toString()); // 3,4,5
console.log(arr instanceof Array); //true

总结：以上方法工作中有些是经常需要用到的，记录一下为了方法工作中方便的处理数据，得到自己想要的数据

JS对象常用方法总结

1. charAt()

2. charCodeAt()

3. conca()

4. indexOf()

5. match()

6. replace()

7. search()

8. split()

9. slice()

10. toLocaleLowerCase()

11. toLowerCase()

12. toLocaleUpperCase()

13. substr()

15. subString()

数组 array

1. slice[start,end]

2. splice()

3. pop()

4. push()

5. shift()

6. unshift()

7. sort()

8. concat(3,4)

9. indexOf()

10. join()

11. forEach()

12. map()

13. for in 方法

ES5-every 和 some 方法

ES5-Array.isArray(obj)