方法一：charAt()：返回在指定位置的字符
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
console.log(str2); // o
console.log(str3); // a
console.log(str4); // m
方法二：charCodeAt()：返回咋指定位置的字符的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
方法三：conca()：连接字符串
var str1 = "lixiaoqi";
var str2 = 'zaijian';
console.log(str2.concat(str1));//把str1连接到str2上
// 结果 lixiaoqizaijian
方法四： indexOf()： 检索字符串，返回的是字符在字符串的下标
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
 
方法五：match()：在字符串内检索指定的值或找到一个或多个正则表达式的匹配，返回的是值而不是值的位置。
var str1 = "lixiaoqi";
var str2 = str1.match('iao'); //检索字符串，返回的是字符
var str3 = str1.match('lll');//没有指定的字符，返回的是null
console.log(str2);
console.log(str3);
方法六：replace()：替换匹配的字符串 
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);
方法七：search()：检索与字符串匹配的子串，返回的是地址 
ar str1 = "lixiaoqi nihaoya zaiganma";
var str2 = "nihaoya";
var str3 = "wobuzai";
var num1 = str1.search(str2);//返回的是第一个字符所在的位置
var num2 = str1.search(str3); //未检测到返回-1
console.log(num1);
console.log(num2);
方法8：slice()：提取字符串片段，并在新的字符串中返回被提取的部分 
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));//返回的是空字符串
方法9：split()：把字符分割成数组 方法 
var str1 = "nihao-zaijian-dajiahao";
console.log(str1.split(''));
var str2 = str1.split('-');
console.log(str2);
console.log(str1);//原字符串不变
10：toLocaleLowerCase()：把字符串转换成小写 
var str = "NIHAOME WOHENHAOnizaiganmane";
console.log(str.toLocaleLowerCase());
var str1 = str.toLocaleLowerCase();
console.log('-----------');
console.log(str1);
console.log(str);//原字符串不变
方法11：toLocaleUpperCase()：把字符串准换成大写 
var str = "deawwWWEzaiganmane";
console.log(str.toLocaleUpperCase());
var str1 = str.toLocaleUpperCase();
console.log('-----------');
console.log(str1);
console.log(str);//原字符串不变
方法12：toLowerCase()：把字符串转换成小写 
var str = "deawwWWEzaiganmane";
console.log(str.toLowerCase());
var str1 = str.toLowerCase();
console.log('-----------');
console.log(str1);
console.log(str);//原字符串不变
方法13：toUpperCase():把字符串转换成大写 
var str = "deawwWWEzaiganmane";
console.log(str.toUpperCase());
var str1 = str.toUpperCase();
console.log('-----------');
console.log(str1);
console.log(str);//原字符串不变
方法14：substr()：从起始索引号提取字符串中指定书目的字符 
var str = "nihaoya wohenhao dajiahao"
var str3 = str.substr(3,19);//字符串中空格不占位置，从3开始，到19结束
console.log(str3);
方法15：subString()：提取字符串中两个指定索引号之间的字符 
var str = "nihaoya wohenhao dajiahao"
var str3 = str.substring(3,19);//字符串中空格占位置，从3开始，到18结束
var str4 = str.substr(3,19);//空格不占位。从3开始到19结束
console.log(str4);
console.log('-------------');
console.log(str3);
 方法16: Object.assign()方法用于将所有可枚举属性的值从一个或多个源对象复制到目标对象，它将返回目标对象。
 语法: Object.assign(target, ...sources)
参数: target目标对象。sources源对象。
使用 
 var obj = { a: 1 };
 var copy = Object.assign({}, obj);
 console.log(copy);        // { a: 1 }
方法17: Object.entries()返回一个数组，其元素是与直接在object上找到的可枚举属性键值对相对应的数组。属性的顺序与通过手动循环对象的属性值所给出的顺序相同。
  
.当键值为正常字符时，返回的键的值为字符串
    var obj1 = {a:1,b:2};
    var obj2 = Object.entries(obj1);
    console.log(obj2) ;      //  [ ["a":1],["b":2] ] 
 
（2）.当键值为数字时，返回的键的值也是字符串
    var obj = { 0: 'a', 1: 'b', 2: 'c' };
    console.log(Object.entries(obj));     // [ ['0', 'a'], ['1', 'b'], ['2', 'c'] ] 
 
（3）.当键值的数字错乱无序时，它会将其排序后返回
   var anObj = { 100: 'a', 2: 'b', 9: 'c' };
   console.log(Object.entries(anObj));   //[["2","b"],["9","c"],["100","a"]]
 方法18: Object.is()方法判断两个值是否是相等的值
Object.is(value1, value2);

参数

value1
需要比较的第一个值。
value2
需要比较的第二个值。

返回值

表示两个参数是否相同的Boolean
  
(1).比较字符串(单纯的比较字符串的每一位，如果完全相同返回true,只要有一个不一样，返回false)
Object.is('foo', 'foo’);          //true;  
Object.is('fo', 'foo’);           //false


(2).比较数组 (对数组无感，即使是相同的数组，或者是相同的空数组，都返回false)
Object.is([11,12],[11,12]).        //false
Object.is([],[])                   //false 
 
(3).比较window
Object.is(window, window)           //true
Object.is(window, document);       //false
 
(4).比较特殊对象undifined 和null(undefined和null都等于它本身，但undefined不等于null)
Object.is(null, null);                      //true
Object.is(undefined,undefined);            //true
Object.is(undefined,null);                 //false 
 
(5)比较正常对象()
复制代码
var test={a:1,b:2};     
var test1={a:2,b:5};
Object.is(test,test1)            //false
----------------------------------------------------------
var test={a:1,b:2};              //比较的两端需为一样的元素，当一边为变量时，另一边也必须是变量
Object.is(test,{a:1,b:2}).       //false
Object.is(test,test).            //true。
方法19:obj.hasOwnProperty(key) 检测对象有没有指定的key,返回布尔值
hasOwnProperty() 方法会返回一个布尔值，指示对象是否具有指定的属性作为自身（不继承）属性。
var obj=new Object();
    obj.a=5;
console.log(obj.hasOwnProperty('a’))       // true
delete obj.a;
console.log(obj.hasOwnProperty(‘a’)).     //false

方法20: Object.values()方法返回一个给定对象自己的所有可枚举属性值的数组，值的顺序与使用for in 循环相同，返回的对象的value值，与Object.key()相反  

（1）正常对象
var obj={a:1,b:2,c:3};
console.log(Object.values(obj))         //  [1, 2, 3]. 
 
（2）类数组对象
var obj ={0:'a',1:'b',2:'c'};
console.log(Object.values(obj)).       //  a,b,c
 
(3)  key值为无序number
var obj={100:'a',10:'b',1:'1'};
console.log(Object.values(obj)).   // ["1", "b", "a"]
 方法21: Object.keys()方法返回一个由一个给定对象的自身可枚举属性组成的数组，数组的属性吗的排列顺序和使用for in 循环遍历该对象时返回的顺序一致
   两者的主要区别是 一个 for-in 循环还会枚举其原型链上的属性 
描述: Object.keys 返回一个所有元素为字符串的数组，其元素来自于从给定的对象上面可直接枚举的属性。这些属性的顺序与手动遍历该对象属性时的一致。
 
（1）数组Array对象（返回索引值）
var arr=[1,2,3];            
Object.keys(arr)         //  ["0", "1", "2”]
 
(2)object对象(返回key值)
var obj = { foo: "bar", baz: 42 };
Object.keys(obj)        //  ["foo", "baz”]
 
(3)类数组，对象
var obj = { 0 : "a", 1 : "b", 2 : "c”};
Object.keys(obj)       // ["0", "1", "2"]
 
(4)类数组对象 随机key排序
var Obj = { 100: 'a’, 2: 'b’,7: 'c’ };
console.log(Object.keys(Obj));     // ['2', '7', '100’]. 返回从小到大排序后的结果
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
s