js内置对象(常用)

数组

Array.isArray() 用于确定传递的值是否是一个 Array。
Array.isArray([1, 2, 3]);  
// true
Array.isArray({foo: 123}); 
// false
Array.isArray("foobar");   
// false
Array.isArray(undefined);  
// false

push() 方法将一个或多个元素添加到数组的末尾，并返回该数组的新长度。
const animals = ['pigs', 'goats', 'sheep'];
const count = animals.push('cows');
console.log(count);
// expected output: 4 这里输出的是数组长度
console.log(animals);
// expected output: Array ["pigs", "goats", "sheep", "cows"]

unshift() 方法将一个或多个元素添加到数组的开头，并返回该数组的新长度(该方法修改原有数组)。
const array1 = [1, 2, 3];
console.log(array1.unshift(4, 5));
// expected output: 5 这里输出的是数组长度
console.log(array1);
// expected output: Array [4, 5, 1, 2, 3]

pop()方法从数组中删除最后一个元素，并返回该元素的值。此方法更改数组的长度。
const plants = ['broccoli', 'cauliflower', 'cabbage', 'kale', 'tomato'];
console.log(plants.pop());
// expected output: "tomato"
console.log(plants);
// expected output: Array ["broccoli", "cauliflower", "cabbage", "kale"]

shift() 方法从数组中删除第一个元素，并返回该元素的值。此方法更改数组的长度。
const array1 = [1, 2, 3];
const firstElement = array1.shift();
console.log(array1);
// expected output: Array [2, 3]
console.log(firstElement);
// expected output: 1 这里是删除元素的值

indexOf()方法返回在数组中可以找到一个给定元素的第一个索引，如果不存在，则返回-1。
const beasts = ['ant', 'bison', 'camel', 'duck', 'bison'];
console.log(beasts.indexOf('bison'));
// expected output: 1
// start from index 2
console.log(beasts.indexOf('bison', 2));
// expected output: 4
console.log(beasts.indexOf('giraffe'));
// expected output: -1

lastIndexOf() 方法返回指定元素（也即有效的 JavaScript 值或变量）在数组中的最后一个的索引，如果不存在则返回 -1。
eg：数组去重算法
function unique(arr){
        var arr1=[]
        for(var i=0;i<arr.length;i++){
            if(arr1.indexOf(arr[i])===-1){
                arr1[arr1.length]=arr[i];
            }
        }
        return arr1;
    }
    var arr=['aa',1,1,6,'aa',6,88,99];
    console.log(unique(arr));
    
toString() 返回一个字符串，表示指定的数组及其元素。
const array1 = [1, 2, 'a', '1a'];
console.log(array1.toString());
// expected output: "1,2,a,1a"

join() 方法将一个数组（或一个类数组对象）的所有元素连接成一个字符串并返回这个字符串。如果数组只有一个项目，那么将返回该项目而不使用分隔符。
const elements = ['Fire', 'Air', 'Water'];
console.log(elements.join());
// expected output: "Fire,Air,Water"
console.log(elements.join(''));
// expected output: "FireAirWater"
console.log(elements.join('-'));
// expected output: "Fire-Air-Water"

slice() 方法返回一个新的数组对象，这一对象是一个由 begin 和 end 决定的原数组的浅拷贝（包括 begin，不包括end）。原始数组不会被改变。
const animals = ['ant', 'bison', 'camel', 'duck', 'elephant'];

console.log(animals.slice(2));
// expected output: Array ["camel", "duck", "elephant"]

console.log(animals.slice(2, 4));
// expected output: Array ["camel", "duck"]

console.log(animals.slice(1, 5));
// expected output: Array ["bison", "camel", "duck", "elephant"]
splice() 方法通过删除或替换现有元素或者原地添加新的元素来修改数组,并以数组形式返回被修改的内容。此方法会改变原数组。

const months = ['Jan', 'March', 'April', 'June'];
months.splice(1,0, 'Feb');
// inserts at index 1
console.log(months);
// expected output: Array ["Jan", "Feb", "March", "April", "June"]

months.splice(4, 3, 'May');
// replaces 1 element at index 4
console.log(months);
// expected output: Array ["Jan", "Feb", "March", "April", "May"]

字符串

(字符串得不可变性10121564)

indexOf() 方法返回调用它的 String 对象中第一次出现的指定值的索引，从 fromIndex 处进行搜索。如果未找到该值，则返回 -1。
//用法同数组indexof()
eg:查找相同个数
var str='abcoefoxyozzopp';
    var p=0,q=0;
    while(str.indexOf('o',p)!=-1){
        p=str.indexOf('o',p)+1;
        q++;
    }
    console.log(q);
   
charAt() 方法从一个字符串中返回指定的字符。

charCodeAt() 方法返回0到65535之间的整数，表示给定索引处的UTF-16代码单元 
(在 Unicode 编码单元表示一个单一的 UTF-16 编码单元的情况下，UTF-16 编码单
元匹配 Unicode 编码单元。但在——例如 Unicode 编码单元 > 0x10000 的这种——不
能被一个 UTF-16 编码单元单独表示的情况下，只能匹配 Unicode 代理对的第一个
编码单元) 。如果你想要整个代码点的值，使用 codePointAt()。
var str='andy';//str[index] H5
str[0]//a
eg:1.查询个个字母个数
    var str='abcoefoxyozzopp';
    var obj={

    }
    for(var i=0;i<str.length;i++){
        if(obj[str.charAt(i)]){
            obj[str.charAt(i)]++
        }else{
            obj[str.charAt(i)]=1;
        }
    }
    console.log(obj);
   2.遍历最大字母
    var max=0,letter='';

    for(var key in obj){
        if(obj[key]>max){
            max=obj[key];
            letter=key;
        }
    }
    console.log(max);
    console.log(letter);

slice() 方法提取某个字符串的一部分，并返回一个新的字符串，且不会改动原字符串。
const str = 'The quick brown fox jumps over the lazy dog.';

console.log(str.slice(31));
// expected output: "the lazy dog."

console.log(str.slice(4,20));
// expected output: "quick brown fox "

console.log(str.slice(-4));
// expected output: "dog."

console.log(str.slice(-9, -5));
// expected output: "lazy"
substr() 方法返回一个字符串中从指定位置开始到指定字符数的字符。
var str = "abcdefghij";

console.log("(1,2): "    + str.substr(1,2));   // (1,2): bc
console.log("(-3,2): "   + str.substr(-3,2));  // (-3,2): hi
console.log("(-3): "     + str.substr(-3));    // (-3): hij
console.log("(1): "      + str.substr(1));     // (1): bcdefghij
console.log("(-20, 2): " + str.substr(-20,2)); // (-20, 2): ab
console.log("(20, 2): "  + str.substr(20,2));  // (20, 2):

replace() 方法返回一个由替换值（replacement）替换一些或所有匹配的模式（pattern）后的新字符串。模式可以是一个字符串或者一个正则表达式，替换值可以是一个字符串或者一个每次匹配都要调用的回调函数。
替换所有字母
方法1：
var str='abcoefoxyozzopp';
    const regex = /o/gi;
    console.log(str.replace(regex,'*'));
方法2：
 while(str.indexOf('o')!==-1){
        str=str.replace('o','*');
    }
    console.log(str);

split() 方法使用指定的分隔符字符串将一个String对象分割成子字符串数组，以一个指定的分割字串来决定每个拆分的位置。 
const str = 'The quick brown fox jumps over the lazy dog.';

const words = str.split(' ');
console.log(words[3]);
// expected output: "fox"

const chars = str.split('');
console.log(chars[8]);
// expected output: "k"

const strCopy = str.split();
console.log(strCopy);
// expected output: Array ["The quick brown fox jumps over the lazy dog."]

简单数据类型

1.//简单数据类型null 返回的是一个空对象 object
var timer=null;
console.log(typeof timer);
//如果有个变量我们以后打算存储对象，暂时没想好放啥，这个时候就给null
//简单数据类型又叫(值类型)，复杂数据类型又叫(引用类型)
*值类型：简单数据类型/基本数据类型，在存储变量中存储的是值本身，因此叫做值类型string,number,boolean,undefined,null
*引用类型：复杂数据类型，在存储变量中存储的仅仅是地址(引用)，因此叫做引用数据类型通过new关键字创建的对象(系统对象自定义对象),如Object，Array，Date等
2.队和栈
简单数据类型存放在栈里面 复杂数类型存在堆里面
(1)简单数据类型是存在栈里面的里面直接开辟一个空间存放的是一个值
(2)复杂数据类型首先在栈里面存放地址 十六进制表示 然后这个地址指向堆里面的数据 eg:var arr=[1,2,3] arr就是栈内存放地址 [1,2,3]值放在堆里面由arr指向堆内存 ps:js基础10121574