JS 对象 Object, 内置对象 Array、String、Number、Date、Math、JSON 常用方法

已于 2023-01-19 16:22:02 修改
阅读量377 收藏 1
点赞数
分类专栏： html、css、js 文章标签： javascript Powered by 金山文档
于 2023-01-19 14:52:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/guorui999/article/details/128734971
版权

Object

  • Object.create()

创建一个对象 
const obj = Object.create({a:1}, {b: {value: 2}})

// 第一个参数为对象，是函数调用后返回新对象的原型对象，第二个参数为对象本身的实例方法（默认不能修改,不能枚举）

  • Object.defineProperty()

Object.defineProperty(object, prop, descriptor)定义对象属性
1.第一个参数必须为对象
2.descriptor 不能同时具有 （value 或 writable 特性）（get 或 set 特性）
3.configurable 为false 时，不能重新修改装饰器 
// 添加数据属性
var obj = {};
 
// 1.添加一个数据属性
Object.defineProperty(obj, "newDataProperty", {
    value: 101,
    writable: true,
    enumerable: true,
    configurable: true
});
 
obj.newDataProperty    // 101
 
// 2.修改数据属性
Object.defineProperty(obj, "newDataProperty", {
    writable:false
});
 
//添加访问器属性
var obj = {};
 
Object.defineProperty(obj, "newAccessorProperty", {
    set: function (x) {
        this.otherProperty = x;
    },
    get: function () {
        return this.otherProperty;
    },
    enumerable: true,
    configurable: true
});

  • Object.defineProperties()

Object.defineProperties(object, {prop1 : descriptor1, prop2 : descriptor2, ...)定义对象属性 
var obj = {};
Object.defineProperties(obj, {
  'property1': {
    value: true,
    writable: true
  },
  'property2': {
    value: 'Hello',
    writable: false
  }
  // etc. etc.
});

  • Object.keys()

返回参数对象自身的(不含继承的)所有可遍历(enumerable)属性的键名 
let arr = ["a", "b", "c"];
let obj = { foo: "bar", baz: 42 };
let ArrayLike = { 0 : "a", 1 : "b", 2 : "c"};
 
Object.keys(arr)        // ['0', '1', '2']
Object.keys(obj)        // ["foo","baz"]
Object.keys(ArrayLike)  // ['0', '1', '2']

  • Object.values()

返回参数对象自身的(不含继承的)所有可遍历(enumerable)属性的值 
let arr = ["a", "b", "c"];
let obj = { foo: "bar", baz: 42 };
let ArrayLike = { 0 : "a", 1 : "b", 2 : "c"};
 
Object.values(arr)      // ["a", "b", "c"]
Object.values(obj)          // ["bar",42]
Object.values(ArrayLike)    // ["a", "b", "c"]

  • Object.assign()

Object.assign( target, source, source1 ) 方法用于对象的合并，将源对象（source）的所有可枚举属性，复制到目标对象（target）。拷贝的属性是有限制的，只拷贝源对象的自身属性（不拷贝继承属性），也不拷贝不可枚举的属性（enumerable: false） 
const target = { a: 1, b: 1 };
 
const source1 = { b: 2, c: 2 };
const source2 = { c: 3 };
 
Object.assign(target, source1, source2); target // {a:1, b:2, c:3}
 
 
特殊情况：
let obj = {a: 1};
Object.assign(obj, undefined) === obj  // true
Object.assign(obj, null) === obj       // true
 
Object.assign([1, 2, 3], [4, 5])        // [4, 5, 3]
 
Object.assign方法实行的是浅拷贝，而不是深拷贝。
 
const obj1 = {a: {b: 1}};
const obj2 = Object.assign({}, obj1);
 
obj1.a.b = 2;
console.log(obj2.a.b) //2
obj2.a.b = 3
console.log(obj1.a.b) //3

  • Object.getPrototypeOf()

获取指定对象的原型（内部[[Prototype]]属性的值） 
const prototype1 = {};
const object1 = Object.create(prototype1);
 
console.log(Object.getPrototypeOf(object1) === prototype1);   // true
 
注意：Object.getPrototypeOf(Object) 不是 Object.prototype
     Object.getPrototypeOf( Object ) === Function.prototype;  // true

  • Object.setPrototypeOf()

设置一个指定的对象的原型 
const obj = {a: 1}, proto = {b:2}
 
Object.setPrototypeOf(obj, proto)
 
obj.__proto__ === proto     //true

  • toString toLocalString

toString 方法不做过多介绍
区别：
当被转化的值是个时间对象时，toLocaleString会将转化的结果以本地表示。
 
(newDate).toString(); //"Mon Nov 06 2017 13:02:46 GMT+0800 (China Standard Time)"
 
(newDate).toLocaleString();  //"2017/11/6 下午1:03:12"
 
另外当被转化的值是个时间戳时，toLocaleString会把时间戳每三位添加一个逗号，代码如下。
 
(Date.parse(newDate())).toLocaleString() //"1,509,944,637,000"
 
(Date.parse(newDate())).toString() //"1509944643000"

  • valueOf

需要返回对象的原始值 
备注：js对象中的valueOf()方法和toString()方法非常类似，但是，当需要返回对象的原始值而非字符串的时候才调用它，尤其是转换为数字的时候。如果在需要使用原始值的上下文中使用了对象，JavaScript就会自动调用valueOf()方法。
 
const o = {a: 1, valueOf: function(){ return 123123 } }
Number(o)    //123123
 
// 给大家出一个题
const o2 = {
    x: 1,
    valueOf: function(){
        return this.x++
    }
}
 
if(o2 == 1 && o2 == 2 && o2 == 3){
    console.log('down')
    console.log(o2.x)
}else{
    console.log('faild')
}
 
// Array：返回数组对象本身
var array = ["CodePlayer", true, 12, -5];
array.valueOf() === array;   // true
 
// Date：当前时间距1970年1月1日午夜的毫秒数
var date = new Date(2013, 7, 18, 23, 11, 59, 230);
date.valueOf()     // 1376838719230
 
// Number：返回数字值
var num =  15.26540;
num.valueOf()     // 15.2654
 
// 布尔：返回布尔值true或false
var bool = true;
bool.valueOf() === bool    // true
// new一个Boolean对象
var newBool = new Boolean(true);
// valueOf()返回的是true，两者的值相等
newBool.valueOf() == newBool     // true
// 但是不全等，两者类型不相等，前者是boolean类型，后者是object类型
newBool.valueOf() === newBool     // false
 
// Function：返回函数本身
function foo(){ 
}
foo.valueOf() === foo      // true
var foo2 =  new Function("x", "y", "return x + y;");
foo2.valueOf() === foo2    // true
 
// Object：返回对象本身
var obj = {name: "张三", age: 18};
obj.valueOf() === obj        // true
 
// String：返回字符串值
var str = "http://www.365mini.com";
str.valueOf() === str       // true
// new一个字符串对象
var str2 = new String("http://www.365mini.com");
// 两者的值相等，但不全等，因为类型不同，前者为string类型，后者为object类型
str2.valueOf() === str2      // false

  • isPrototypeOf

isPrototypeOf方法用于测试一个对象是否存在于另一个对象的原型链上
 
function Foo() {}
function Bar() {}
function Baz() {}
 
Bar.prototype = Object.create(Foo.prototype);
Baz.prototype = Object.create(Bar.prototype);
 
var baz = new Baz();
 
console.log(Baz.prototype.isPrototypeOf(baz)); // true
console.log(Bar.prototype.isPrototypeOf(baz)); // true
console.log(Foo.prototype.isPrototypeOf(baz)); // true
console.log(Object.prototype.isPrototypeOf(baz)); // true

  • hasOwnProperty

方法会返回一个布尔值，指示对象自身属性中是否具有指定的属性
 
let o = {a: 1 }
 
o.hasOwnProperty('a')   //true
o.hasOwnProperty('b')   //false   对象自身没有属性b
o.hasOwnProperty('toString');  //false  不能检测对象原型链上的属性
 
 
如何遍历一个对象的所有自身属性，例子：
var buz = {
    fog: 'stack'
};
 
for (var name in buz) {
    if (buz.hasOwnProperty(name)) {
       console.log("this is fog (" + name + ") for sure. Value: " + buz[name]);
    }
    else {
       console.log(name); // toString or something else
    }
}

  • Object.entries

分割对象 
const obj = { foo: 'bar', baz: 42 };
console.log(Object.entries(obj)); // [ ['foo', 'bar'], ['baz', 42] ]
 
// array like object
const obj = { 0: 'a', 1: 'b', 2: 'c' };
console.log(Object.entries(obj)); // [ ['0', 'a'], ['1', 'b'], ['2', 'c'] ]
 
//  string
Object.entries('abc')   // [['0', 'a'], ['1', 'b'], ['2', 'c']]
 
Object.entries(100)   // []

  • Object.fromEntries

Object.entries()方法正好相反，Object.entries()方法会返回给定对象的键值对数组 
const a = [['test', 'test1'],['testme', 'testme1'],['sugers', 'sugers1']]
Object.fromEntries(a)
结果为:
{test: 'test1', testme: 'testme1', sugers: 'sugers1'}

const a = new Map()
a.set('aa', 1)
a.set('bb', 2)
Object.fromEntries(a)
结果为:
{aa: 1, bb: 2}

Array

  • length

设置或返回数组元素的个数 
console.log([1,2,3].length) // 3

  • concat

连接两个或更多的数组，并返回结果 
var a = ["Google", "Taobao"];
var b = ["Runoob", "Wiki", "Zhihu"];
var c = a.concat(b);
console.log(c); //  ["Google", "Taobao","Runoob", "Wiki", "Zhihu"]

  • slice

可从已有的数组中返回选定的元素
可提取字符串的某个部分，并以新的字符串返回被提取的部分
array.slice(start, end)
start 可选。规定从何处开始选取。如果该参数为负数，则表示从原数组中的倒数第几个元素开始提取，slice(-2) 表示提取原数组中的倒数第二个元素到最后一个元素（包含最后一个元素）。
end 可选。规定从何处结束选取。该参数是数组片断结束处的数组下标。如果没有指定该参数，那么切分的数组包含从 start 到数组结束的所有元素。如果该参数为负数， 则它表示在原数组中的倒数第几个元素结束抽取。 slice(-2,-1) 表示抽取了原数组中的倒数第二个元素到最后一个元素（不包含最后一个元素，也就是只有倒数第二个元素）。 
var fruits = ["Banana", "Orange", "Lemon", "Apple", "Mango"];
var citrus = fruits.slice(1,3);
console.log(citrus) // ["Orange", "Lemon"]

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

var fruits = ["Banana", "Orange", "Lemon", "Apple", "Mango"]; 
var myBest = fruits.slice(-3,-1); // 截取倒数第三个（包含）到倒数第一个（不包含）的两个元素
console.log(myBest) // ["Lemon", "Apple"]
var myBest = fruits.slice(-3); // 截取最后三个元素
console.log(myBest) // ["Lemon", "Apple", "Mango"]

  • join

把数组中的所有元素转换为一个字符串
array.join(separator)
separator 可选。指定要使用的分隔符。如果省略该参数，则使用逗号作为分隔符。 
var fruits = ["Banana", "Orange", "Apple", "Mango"];
var energy = fruits.join();
console.log(energy) // 'Banana,Orange,Apple,Mango'

  • reverse

颠倒数组中元素的顺序
数组变更方法(修改数组本身) 
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.reverse();
console.log(fruits) //  ["Mango", "Apple", "Orange", "Banana"]

  • find

返回通过测试（函数内判断）的数组的第一个元素的值 
var ages = [16, 33, 16, 40];

console.log(ages.find((age) => age >= 18)) // 33

  • fill

使用固定值填充数组 
var fruits = ["Banana", "Orange", "Apple", "Mango"]; 
fruits.fill("Runoob");
console.log(fruits) // ["Runoob", "Runoob", "Runoob", "Runoob"]

  • findIndex

返回传入一个测试条件（函数）符合条件的数组第一个元素位置 
var ages = [16, 33, 16, 40];

console.log(ages.findIndex((age) => age >= 18)) // 1

  • indexOf

返回数组中某个指定的元素位置, 没找到返回 -1 
var fruits = ["Banana", "Orange", "Apple", "Mango"]; 
var a = fruits.indexOf("Apple");
console.log(a) // 2

  • lastIndexOf

返回一个指定的元素在数组中最后出现的位置，从该字符串的后面向前查找 
var fruits = ["Banana", "Orange", "Apple", "Mango"];
var a = fruits.lastIndexOf("Apple");
console.log(a) // 2

  • includes

用来判断一个数组是否包含一个指定的值，如果是返回 true，否则false
arr.includes(searchElement)
arr.includes(searchElement, fromIndex) 
[1, 2, 3].includes(2);     // true
[1, 2, 3].includes(4);     // false
[1, 2, 3].includes(3, 3);  // false
[1, 2, 3].includes(3, -1); // true
[1, 2, NaN].includes(NaN); // true

  • forEach

用于调用数组的每个元素，并将元素传递给回调函数 
[1,3,4,5].forEach((item, index, arr) => {
    console.log(item,index)
})

// 1 0// 3 1// 4 2// 5 3

  • map

返回一个新数组，数组中的元素为原始数组元素调用函数处理后的值
按照原始数组元素顺序依次处理元素
array.map(function(currentValue,index,arr), thisValue)
currentValue 必须。当前元素的值
index 可选。当前元素的索引值
arr 可选。当前元素属于的数组对象 
var numbers = [4, 9, 16, 25];

const arr = numbers.map((item) => item * 2)
console.log(arr) // [8, 18, 32, 50]

  • some

用于检测数组中的元素是否满足指定条件（函数提供）
some() 方法会依次执行数组的每个元素：
如果有一个元素满足条件，则表达式返回 true , 剩余的元素不会再执行检测。
如果没有满足条件的元素，则返回false。 
var ages = [3, 10, 18, 20];

console.log(ages.some(age => age >=18)) // true

  • every

遍历数组,有一个不满足返回false,全满足返回true 
var ages = [32, 33, 16, 40];

console.log(ages.every((age) => age >= 18)) // false

  • filter

创建一个新的数组，新数组中的元素是通过检查指定数组中符合条件的所有元素 
var ages = [32, 33, 16, 40];
console.log(ages.filter((age) => age >= 18)) // [32,33,40]

  • pop

用于删除数组的最后一个元素并返回删除的元素
数组变更方法(修改数组本身) 
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.pop();
console.log(fruits) // ["Banana", "Orange", "Apple"]

  • push

可向数组的末尾添加一个或多个元素，并返回新的长度
数组变更方法(修改数组本身)
array.push(item1, item2, ..., itemX)
item1, item2, ..., itemX 必需。要添加到数组的元素。 
var fruits = ["Banana", "Orange", "Apple", "Mango"];  
fruits.push("Kiwi")
console.log(fruits) // ["Banana", "Orange", "Apple", "Mango", "Kiwi"]

  • shift

用于把数组的第一个元素从其中删除，并返回第一个元素的值
数组变更方法(修改数组本身) 
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.shift()
console.log(fruits) // ["Orange", "Apple", "Mango"]

  • unshift

可向数组的开头添加一个或更多元素，并返回新的长度
数组变更方法(修改数组本身)
array.unshift(item1,item2, ..., itemX)
item1,item2, ..., itemX 可选。向数组起始位置添加一个或者多个元素。 
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.unshift("Lemon","Pineapple");
console.log(fruits) // ["Lemon","Pineapple","Banana", "Orange", "Apple", "Mango"]

  • splice

用于添加或删除数组中的元素
数组变更方法(修改数组本身)
array.splice(index,howmany,item1,.....,itemX)
index 必需。规定从何处添加/删除元素。 该参数是开始插入和（或）删除的数组元素的下标，必须是数字。
howmany 可选。规定应该删除多少元素。必须是数字，但可以是 "0"。 如果未规定此参数，则删除从 index 开始到原数组结尾的所有元素。
item1, ..., itemX 可选。要添加到数组的新元素 
// 添加新元素
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.splice(2,0,"Lemon","Kiwi");
console.log(fruits) // ["Banana", "Orange", "Lemon", "Kiwi", "Apple", "Mango"]

// 从第三个位置开始删除数组后的两个元素
fruits.splice(2,2);
console.log(fruits) // ["Banana", "Orange", "Apple", "Mango"]

// 移除数组的第三个元素，并在数组第三个位置添加新元素
fruits.splice(2,1,"Lemon","Kiwi")
console.log(fruits) // ["Banana", "Orange", "Lemon","Kiwi", "Mango"]

  • Array.from()

通过字符串创建一个数组
Array.from(object, mapFunction, thisValue)
object 必需，要转换为数组的对象。
mapFunction 可选，数组中每个元素要调用的函数。
thisValue 可选，映射函数(mapFunction)中的 this 对象。 
var myArr = Array.from("RUNOOB");

  • isArray()

判断对象是否为数组 
console.log(Array.isArray([1])) // trueconsole.log(Array.isArray('22')) // false

  • reduce

接收一个函数作为累加器，数组中的每个值（从左到右）开始缩减，最终计算为一个值
可以作为一个高阶函数，用于函数的 compose
array.reduce(function(total, currentValue, currentIndex, arr), initialValue)
total 必需。初始值, 或者计算结束后的返回值
currentValue 必需。当前元素
currentIndex 可选。当前元素的索引
arr 可选。当前元素所属的数组对象
initialValue 可选。传递给函数的初始值 
var numbers = [65, 44, 12, 4];

const sum = numbers.reduce((total, num) => total + num)

console.log(sum) // 125

  • sort

用于对数组的元素进行排序
数组变更方法(修改数组本身)
array.sort(sortfunction)
排序顺序可以是字母或数字，并按升序或降序。默认排序为按字母升序
注意：当数字是按字母顺序排列时"40"将排在"5"前面。
使用数字排序，你必须通过一个函数作为参数来调用。
函数指定数字是按照升序还是降序排列。 
// 按字母排序
var fruits = ["Banana", "Orange", "Apple", "Mango"];  
fruits.sort();
console.log(fruits) // ["Apple", "Banana", "Mango", "Orange"]
// 数字排序
var points = [40,100,1,5,25,10];  
points.sort(function(a,b){return a-b});
console.log(points) // [1,5,10,25,40,100]
points.sort(function(a,b){return b-a});
console.log(points) // [100,40,25,10,5,1]

  • toString

可把数组转换为字符串，并返回结果
数组的所有值用逗号隔开 
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.toString();
console.log(fruits) // "Banana,Orange,Apple,Mango"

  • valueOf

valueOf() 方法返回 Array 对象的原始值。
该原始值由 Array 对象派生的所有对象继承。
valueOf() 方法通常由 JavaScript 在后台自动调用，并不显式地出现在代码中。 
var fruits = ["Banana", "Orange", "Apple", "Mango"];
var v = fruits.valueOf();
//  fruits.valueOf()与 fruits返回值一样。
console.log(v) // ["Banana", "Orange", "Apple", "Mango"]

  • at

at() 方法接收一个整数值并返回该索引的项目，允许正数和负数。负整数从数组中的最后一个项目开始倒数。 
const array = ['张三','李四','王麻子'];
console.log(array.at(0))  //张三
console.log(array.at(-1)) //王麻子   获取最后一个元素
console.log(array.at(-2)) //李四

String

  • length

返回字符串长度 
console.log('string'.length) // 6

  • concat

连接两个或更多字符串，并返回新的字符串
string.concat(string1, string2, ..., stringX)
string1, string2, ..., stringX 必需。将被连接为一个字符串的一个或多个字符串对象。 
var str1 = "Hello ";
var str2 = "world!";
var n = str1.concat(str2);
console.log(n) // "Hello world!"

  • indexOf

返回某个指定的字符串值在字符串中首次出现的位置
string.indexOf(searchvalue,start)
searchvalue 必需。规定需检索的字符串值。
start 可选的整数参数。规定在字符串中开始检索的位置。它的合法取值是 0 到 string Object.length - 1。如省略该参数，则将从字符串的首字符开始检索。 
var str="Hello world, welcome to the universe.";
var n=str.indexOf("welcome");
console.log(n) // 13

  • lastIndexOf

从后向前搜索字符串，并从起始位置（0）开始计算返回字符串最后出现的位置
string.lastIndexOf(searchvalue,start)
searchvalue 必需。规定需检索的字符串值。
start 可选的整数参数。规定在字符串中开始检索的位置。它的合法取值是 0 到 stringObject.length - 1。如省略该参数，则将从字符串的最后一个字符处开始检索。 
var str="I am from runoob，welcome to runoob site.";
var n=str.lastIndexOf("runoob");
console.log(n) // 28

  • includes

查找字符串中是否包含指定的子字符串
string.includes(searchvalue, start)
searchvalue 必需，要查找的字符串。
start 可选，设置从那个位置开始查找，默认为 0。 
var str = "Hello world, welcome to the Runoob。";
var n = str.includes("Runoob");
console.log(n) // truevar m = str.includes("world", 12)
console.log(m) // false

  • replace

在字符串中查找匹配的子串，并替换与正则表达式匹配的子串
string.replace(searchvalue,newvalue)
searchvalue 必须。规定子字符串或要替换的模式的 RegExp 对象。 请注意，如果该值是一个字符串，则将它作为要检索的直接量文本模式，而不是首先被转换为 RegExp 对象。
newvalue 必需。一个字符串值。规定了替换文本或生成替换文本的函数。
replace函数的第二个参数newvalue比较特殊，它有一下几个特殊字符串
$$ 直接量符号(就是当做'$$'字符用)
$& 与正则相匹配的字符串
$` 匹配字符串左边的字符
$’ 匹配字符串右边的字符
$1,$2,$3,…,$n 匹配结果中对应的分组匹配结果
想要消除$的影响可以写成函数的返回值，函数具有一下几个参数：
第一个参数：匹配到的字符串
中间的参数：如果正则使用了分组匹配就为多个否则无此参数
倒数第二个参数：匹配字符串的对应索引位置
最后一个参数：原始字符串 
// 字符串替换
var str="Visit Microsoft! Visit Microsoft!";
var n=str.replace("Microsoft","Runoob");
console.log(n) // "Visit Runoob! Visit Microsoft!

// 全局替换, 忽略大小写
var str="Mr Blue has a blue house and a blue car";
var n = str.replace(/blue/g,"red");
console.log(n) // "Mr red has a red house and a red car"

// 电话号码加*号
var str ="13400290304"
var n = str.replace(/(\d{3})\d{4}(\d{3})/,"$1****$2")
console.log(n) // "1340****304"

  • replaceAll

在字符串中查找匹配的子串，并替换与正则表达式匹配的所有子串
const newStr = str.replaceAll(regexp|substr, newSubstr|function)
regexp|substr 必须。规定子字符串或要替换的模式的 RegExp 对象。 请注意，如果该值是一个字符串，则将它作为要检索的直接量文本模式，而不是首先被转换为 RegExp 对象。当使用一个 regex 时，您必须设置全局（"g"）标志， 否则，它将引发 TypeError："必须使用全局 RegExp 调用 replaceAll"。
newSubstr|function 必需。一个字符串值。规定了替换文本或生成替换文本的函数。 
var str="Visit Microsoft! Visit Microsoft!";
var n=str.replaceAll("Microsoft","Runoob");
console.log(n) // "Visit Runoob! Visit Runoob!"

  • search

查找与正则表达式相匹配的值, 没有找到返回-1
string.search(searchvalue)
searchvalue 必须。查找的字符串或者正则表达式 
var str="Mr. Blue has a blue house";
console.log(str.search("blue")); 
// 15console.log(str.search(/blue/i)); 
//4

  • slice

提取字符串的片断，并在新的字符串中返回被提取的部分
string.slice(start,end)
start 必须。 要抽取的片断的起始下标，第一个字符位置为 0。如果为负数，则从尾部开始截取。
end 可选。 紧接着要截取的片段结尾的下标。若未指定此参数，则要提取的子串包括 start 到原字符串结尾的字符串。如果该参数是负数，那么它规定的是从字符串的尾部开始算起的位置。slice(-2) 表示提取原数组中的倒数第二个元素到最后一个元素（包含最后一个元素）。 
// 提取下标1到下标4
var str="Hello world!";
var n=str.slice(1,5);
console.log(n) // "ello"

// 提取所有字符串
var str="Hello world!";
var n=str.slice(0);
console.log(n) // "Hello world!"

// 从字符串的第3个位置提取字符串片段
var str="Hello world!";
var n=str.slice(3);
console.log(n) // "lo world!"

// 提取最后一个字符和最后两个字符
var str="Hello world!";
var n=str.slice(-1);
var n2=str.slice(-2);
console.log(n) // "!"
console.log(n2) // "d!"

  • substr

从起始索引号提取字符串中指定数目的字符
string.substr(start,length)
start 必需。要抽取的子串的起始下标。必须是数值。如果是负数，那么该参数声明从字符串的尾部开始算起的位置。也就是说，-1 指字符串中最后一个字符，-2 指倒数第二个字符，以此类推。
length 可选。子串中的字符数。必须是数值。如果省略了该参数，那么返回从 stringObject 的开始位置到结尾的字串。 
// 抽取指定数目的字符var str="Hello world!";
var n=str.substr(2,3)
console.log(n) // "llo"

从字符串第二个位置中提取一些字符
var n=str.substr(2)
console.log(n) // "llo world!"

  • substring

提取字符串中两个指定的索引号之间的字符
string.substring(from, to)
from 必需。一个非负的整数，规定要提取的子串的第一个字符在 string Object 中的位置。
to 可选。一个非负的整数，比要提取的子串的最后一个字符在 string Object 中的位置多 1。 如果省略该参数，那么返回的子串会一直到字符串的结尾。 
var str="Hello world!";
console.log(str.substring(3,7)); // "lo w"

  • split

把字符串分割为字符串数组
string.split(separator,limit)
separator 可选。字符串或正则表达式，从该参数指定的地方分割 string Object。
limit 可选。该参数可指定返回的数组的最大长度。如果设置了该参数，返回的子串不会多于这个参数指定的数组。如果没有设置该参数，整个字符串都会被分割，不考虑它的长度。 
// 把一个字符串分割成字符串数组
var str="How are you doing today?";
var n=str.split(" ");
console.log(n) // ['How', 'are', 'you', 'doing', 'today?']

// 省略分割参数
var n=str.split();
console.log(n) // ['How are you doing today?']

// 分割每个字符，包括空格
var n=str.split("");
console.log(n) // ['H', 'o', 'w', ' ', 'a', 'r', 'e', ' ', 'y', 'o', 'u', ' ', 'd', 'o', 'i', 'n', 'g', ' ', 't', 'o', 'd', 'a', 'y', '?']

// 使用 limit 参数
var n=str.split(" ",3);
console.log(n) // ['How', 'are', 'you']

// 使用一个字符作为分隔符
var n=str.split("o"); // ['H', 'w are y', 'u d', 'ing t', 'day?']

  • toUpperCase

把字符串转换为大写 
var str="Runoob";
console.log(str.toLowerCase()); // 'runoob'

  • toLowerCase

把字符串转换为小写 
var str="Runoob"; 
console.log(str.toUpperCase()); // 'RUNOOB'

  • trim

去除字符串两边的空白 
var str = "       Runoob        ";
console.log(str.trim()); // 'Runoob'

  • valueOf

返回某个字符串对象的原始值 
var str="Hello world!";
console.log(str.valueOf()) // 'Hello world!'

  • toString

返回一个字符串 
var str = "Runoob";
console.log(str.toString()) // 'Runoob'

Number

  • isNaN

检测指定参数是否为 NaN 
Number.isNaN(NaN);        // trueNumber.isNaN(Number.NaN); // trueNumber.isNaN(0 / 0)       // true// 下面这几个如果使用全局的 isNaN() 时，会返回 true。Number.isNaN("NaN");      // false，字符串 "NaN" 不会被隐式转换成数字 NaN。Number.isNaN(undefined);  // falseNumber.isNaN({});         // falseNumber.isNaN("blabla");   // false// 下面的都返回 falseNumber.isNaN(true);
Number.isNaN(null);
Number.isNaN(37);
Number.isNaN("37");
Number.isNaN("37.37");
Number.isNaN("");
Number.isNaN(" ");

  • toFixed

把数字转换为字符串，结果的小数点后有指定位数的数字 
var num = 5.56789;  
var n=num.toFixed(2);
console.log(n) // 5.57

Date

  • new Date() / Date()

创建 Date 对象 
var d = new Date(); // Thu Jan 19 2023 14:11:59 GMT+0800 (中国标准时间)
var d = new Date(milliseconds); // 参数为毫秒
var d = new Date(dateString);
var d = new Date(year, month, day, hours, minutes, seconds, milliseconds);
milliseconds 参数是一个 Unix 时间戳（Unix Time Stamp），它是一个整数值，表示自 1970 年 1 月 1 日 00:00:00 UTC（the Unix epoch）以来的毫秒数。
dateString 参数表示日期的字符串值。
year, month, day, hours, minutes, seconds, milliseconds 分别表示年、月、日、时、分、秒、毫秒。

  • getDate()

从 Date 对象返回一个月中的某一天 (1 ~ 31) 
var d = newDate();  
var n = d.getDate(); // 19

  • getDay()

从 Date 对象返回一周中的某一天 (0 ~ 6) 
var d = newDate();  
var n = d.getDay(); // 4

  • getFullYear()

从 Date 对象以四位数字返回年份 
var d = newDate();  
var n = d.getFullYear(); // 2023

  • getHours()

返回 Date 对象的小时 (0 ~ 23) 
var d = newDate();  
var n = d.getHours(); // 14

  • getMinutes()

返回 Date 对象的分钟 (0 ~ 59) 
var d = newDate();  
var n = d.getMinutes(); // 24

  • getMonth()

从 Date 对象返回月份 (0 ~ 11) 
var d = newDate();  
var n = d.getMonth(); // 0

  • getSeconds()

返回 Date 对象的秒数 (0 ~ 59) 
var d = newDate();  
var n = d.getSeconds(); // 54

  • getTime()

返回 1970 年 1 月 1 日至今的毫秒数 
var d = newDate();  
var n = d.getTime(); // 1674109503457

  • parse()

返回1970年1月1日午夜到指定日期（字符串）的毫秒数 
var d = Date.parse("March 21, 2012"); // 1332259200000

  • setDate()

设置 Date 对象中月的某一天 (1 ~ 31) 
var d = newDate();  
d.setDate(15); // 1673764102758

  • setFullYear()

设置 Date 对象中的年份（四位数字） 
var d = newDate();  
d.setFullYear(2020); // 1579415333050

  • setHours()

设置 Date 对象中的小时 (0 ~ 23) 
var d = newDate();  
d.setHours(20); // 1674131451886

  • setMinutes()

设置 Date 对象中的分钟 (0 ~ 59) 
var d = newDate();  
d.setMinutes(50); // 1674111040024

  • setMonth()

设置 Date 对象中月份 (0 ~ 11) 
var d = newDate();  
d.setMonth(2); // 1679207480993

  • setSeconds()

设置 Date 对象中的秒钟 (0 ~ 59) 
var d = newDate();  
d.setSeconds(56); // 1674109916048

  • setTime()

setTime() 方法以毫秒设置 Date 对象 
var d = newDate();  
d.setTime(1332403882588); // 1332403882588

  • toLocaleDateString()

根据本地时间格式，把 Date 对象的日期部分转换为字符串 
var d=newDate();
var n=d.toLocaleDateString(); // '2023/1/19'

  • toLocaleTimeString()

根据本地时间格式，把 Date 对象的时间部分转换为字符串 
var d=newDate();
var n=d.toLocaleTimeString(); // '14:33:21'

  • toLocaleString()

根据本地时间格式，把 Date 对象转换为字符串 
var d=new Date();
var n=d.toLocaleString(); // '2023/1/19 14:33:40'

// 时间戳转日期 转成'2023-1-19 14:33:40'
function  formatTime(time) {
    if (time) {
      let newTime = new Date(time).toLocaleString();
      return newTime.replaceAll("/", "-");
    } else {
      return "";
    }
}

Math

  • floor

对 x 进行下舍入 
Math.floor(1.6) // 1

  • ceil

对数进行上舍入 
Math.ceil(1.4) // 2

  • max

返回 x,y,z,...,n 中的最高值
Math.max(n1,n2,n3,...,nX)
n1,n2,n3,...,nX 可选。1 或多个值。在 ECMASCript v3 之前，该方法只有两个参数。 
// 非数组参数 
var b=Math.max(0,150,30,20,38); // 150
// 数组参数 
var max=Math.max.apply(null,[1,888,88]) // 888

  • min

返回 x,y,z,...,n中的最低值
Math.min(n1,n2,n3,...,nX)
n1,n2,n3,...,nX 可选。1 或多个值。在 ECMASCript v3 之前，该方法只有两个参数。 
// 非数组参数
var b=Math.min(0,150,30,20,38); // 0
// 数组参数
var max=Math.min.apply(null,[1,888,88]) // 1

  • random

返回 0 ~ 1 之间的随机数 
Math.random(); // 0.6946380009022441

// 在本例中，我们将取得介于 1 到 10 之间的一个随机数
Math.floor((Math.random()*10)+1); // 8

// 在本例中，我们将取得介于 1 到 100 之间的一个随机数
Math.floor((Math.random()*100)+1); //67

// 以下函数返回 min（包含）～ max（不包含）之间的数字
Math.floor(Math.random() * (max - min) ) + min

// 以下函数返回 min（包含）～ max（包含）之间的数字
Math.floor(Math.random() * (max - min + 1) ) + min

  • round

四舍五入 
Math.round(2.5) // 3

JSON

  • JSON.stringify()

将JS值转换为JSON文本字符串 
const json = JSON.stringify(data)

  • JSON.parse()

将JSON文本字符串解析为JS值 
const data = JSON.parse(JSON)

全局函数

  • isNaN

检查某个值是否是数字 
console.log(isNaN(123)+ "<br>"); // false
console.log(isNaN(-1.23)+ "<br>"); // false
console.log(isNaN(5-2)+ "<br>"); // false
console.log(isNaN(0)+ "<br>"); // false
console.log(isNaN("Hello")+ "<br>"); // true
console.log(isNaN("2005/12/12")+ "<br>"); // true

  • Number

把对象的值转换为数字
如果对象的值无法转换为数字，那么 Number() 函数返回 NaN 
var test1= new Boolean(true);
var test2= new Boolean(false);
var test3= new Date();
var test4= new String("999");
var test5= new String("999 888");

console.log(Number(test1)) // 1
console.log(Number(test2)) // 0
console.log(Number(test3)) // 1674099417796
console.log(Number(test4)) // 999
console.log(Number(test5)) // NaN

  • parseFloat

解析一个字符串并返回一个浮点数
该函数指定字符串中的首个字符是否是数字。如果是，则对字符串进行解析，直到到达数字的末端为止，然后以数字返回该数字，而不是作为字符串。 
console.log(parseFloat("10")) // 10
console.log(parseFloat("10.33")) // 10.33
console.log(parseFloat("34 45 66")) // 34
console.log(parseFloat(" 60 ")) // 60
console.log(parseFloat("40 years")) // 40
console.log(parseFloat("He was 40")) // NaN

  • parseInt

解析一个字符串并返回一个整数
parseInt(string, radix)
string 必需。要被解析的字符串。
radix 可选。表示要解析的数字的基数。该值介于 2 ~ 36 之间。 当参数 radix 的值为 0，或没有设置该参数时，parseInt() 会根据 string 来判断数字的基数。
当忽略参数 radix , JavaScript 默认数字的基数如下:
如果 string 以 "0x" 开头，parseInt() 会把 string 的其余部分解析为十六进制的整数。
如果 string 以 0 开头，那么 ECMAScript v3 允许 parseInt() 的一个实现把其后的字符解析为八进制或十六进制的数字。
如果 string 以 1 ~ 9 的数字开头，parseInt() 将把它解析为十进制的整数

当忽略参数 radix , JavaScript 默认数字的基数如下:

如果 string 以 "0x" 开头，parseInt() 会把 string 的其余部分解析为十六进制的整数。 如果 string 以 0 开头，那么 ECMAScript v3 允许 parseInt() 的一个实现把其后的字符解析为八进制或十六进制的数字。 如果 string 以 1 ~ 9 的数字开头，parseInt() 将把它解析为十进制的整数

console.log(parseInt("10") ); // 10
console.log(parseInt("10.33")); // 10
console.log(parseInt("34 45 66")); // 34
console.log(parseInt(" 60 ")); // 60
console.log(parseInt("40 years")); // 40
console.log(parseInt("He was 40")); // NaN
 

console.log(parseInt("10",10)); // 10
console.log(parseInt("010")); // 10
console.log(parseInt("10",8)); // 8
console.log(parseInt("0x10")); // 16
console.log(parseInt("10",16)); // 16

  • String

把对象的值转换为字符串 
var test1 = new Boolean(1);
var test2 = new Boolean(0);
var test3 = new Boolean(true);
var test4 = new Boolean(false);
var test5 = new Date();
var test6 = new String("999 888");
var test7 = 12345;

console.log(String(test1)); // 'true'
console.log(String(test2)); // 'false'
console.log(String(test3)); // 'true'
console.log(String(test4)); // 'false'
console.log(String(test5)); // 'Thu Jan 19 2023 11:56:07 GMT+0800 (中国标准时间)'
console.log(String(test6)); // '999 888'
console.log(String(test7)); // '12345'
前端黄大仙
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值