内置对象
别名：内置构造函数
内置对象的在线文档（MDN）：
https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects
Boolean
把一个原始值当做对象去使用的时候，会自动包装成对象。
js
// 1. 直接量方式
true;
false;
// 2. Boolean 函数方式
Boolean(true);
Boolean(false);
// 3. Boolean 构造函数方式 默认对象状态
new Boolean(true);
new Boolean(false);Number
① 实例的属性和方法
sh
toFixed() 返回指定小数位数的数字，不写参数返回整数（四舍五入）
toString() 返回指定进制形式的字符串，参数2~36② 构造函数本身的属性和方法
js
Number.MAX_VALUE js中可以表示的最大的数字
Number.MIN_VALUE js中可以表示的最小的正数
使用的是Number构造函数属性。String
① 实例的属性和方法
js
length 读取字符串长度，字符个数
charAt() 返回指定位置的字符，参数是指定的索引
indexOf() 返回指定的内容在字符串中第一次出现的位置（索引），参数就是指定的内容
lastIndexOf() 返回指定的内容在字符串中最后一次出现的位置（索引），参数就是指定的内容
slice() 截取字符串并返回，参数指定开始位置和结束位置（结束位置字符不包括在内），不设置第二个参数截取到最后
substring() 截取字符串并返回，规则同上
substr() 截取字符串并返回，参数指定开始位置和截取长度，不设置第二个参数截取到最后
split() 分隔字符串返回数组，参数指定分隔符，''代表空字符串
toUpperCase() 将字符串所有字母转为大写并返回，不需要参数
toLowerCase() 将字符串所有字母转为小写并返回，不需要参数
chatCodeAt() 返回指定位置的字符的unicode编码，，参数是指定的索引
search() 参数是正则表达式，返回字符串中第一个满足正则的部分的索引，无法匹配返回 -1
match() 参数是正则表达式，匹配成功返回数组，无法匹配返回 null
replace() 进行替换，第一个参数是正则表达式；默认只替换一个，替换所有需要进行全局匹配
split() 将字符串分割为数组，可以使用正则指定分割符号
例如 replace(/6/g,"六") 全局把6替换成六
例如：string.split(/[\.,;]/)，[]单个原子，"，。；"都可以作为分割符号
string对象转为数组
array = [string]② 构造函数本身的属性和方法
js
String.fromCharCode() 返回指定unicode编码对应的字符，参数指定unicode编码是个数字js
String.prototype.是实例的原型的属性，是为了让实例使用的。
String.fromCharCode()是构造函数String本身的属性，自己使用。Math
Math 就是系统定义好的对象，是一个 Object 的实例
js
Math.PI 圆周率
Math.abs() 返回绝对值
Math.pow() 返回次方数，两个参数
Math.sqrt() 返回平方根
Math.floor() 返回整数，向下取整
Math.ceil() 返回整数，向上取整
Math.round() 返回整数，四舍五入
Math.max() 返回参数中最大的，参数数量可以是任意个
Math.min() 返回参数中最小的，参数数量可以是任意个
Math.random() 返回一个随机数，范围是0到1,0可能会被取到，1不可能。取随机整数： 0 ~ n
js
Math.floor(Math.random() * (n+1))取随机整数： m ~ n
js
Math.floor(Math.random() * (n-m+1)) + m;
先取区间随机整数，取出来的数字加底数Date
创建一个 date 对象
① 实例化日期时间对象
如果没有提供参数，那么新创建的 Date 对象表示实例化时刻的日期和时间。
value 表示一个时间戳
dateString 表示日期的字符串值，如“December 17, 1995 03:24:00” 或者 “1995-12-17T03:24:00”
js
// 实例化日期时间对象 不写参数包含当前的日期时间
var d1 = new Date();
// 实例化日期时间对象 指定日期时间
var d2 = new Date('December 17, 1995 03:24:00');
// 实例化日期时间对象 指定日期时间
var d3 = new Date('2008-09-12T10:06:45');
// 实例化日期时间对象 指定日期时间
var d4 = new Date(1949,9,1,10,0,12);
var d5 = new Date(1997,6);
var d6 = new Date(1997,6,10,8);
// 实例化日期对象 指定日期时间 参数是unix时间戳(1970.1.1 00:00:00 距离目标日期的毫秒数)
var d7 = new Date(360000000000);② 实例的属性和方法
js
getFullYear() 获取年，公元纪年
getMonth() 获取月，月的取值0~11
getDate() 获取每月第几天
getDay() 获取每周第几天
getHours() 获取时
getMinutes() 获取分
getSeconds() 获取秒
getMilliseconds() 获取毫秒
getUTC... 获取零时区的年月日时分秒...
getTime() 获取时间戳，从1970-01-01 00:00:00 距离日期时间对象的毫秒数
set... 设置日期时间
setUTC... 设置零时区日期时间
setTime() 设置时间戳③ 构造函数本身的属性和方法
js
Date.now() 获取此时此刻的时间戳，没有参数
Date.UTC() 获取指定日期的时间戳，用2~6个数字表示年月日时间秒| 方法名 | 含义 |
|---|---|
| Date.now() | 返回自 1970-1-1 00:00:00 UTC（世界标准时间）至今所经过的毫秒数。 |
| Date.UTC() | 返回从1970-1-1 00:00:00 UTC到指定日期的的毫秒数。 Date.UTC(year,month[,date[,hrs[,min[,sec[,ms]]]]]) |
| getYear() | 根据特定日期返回年份 (通常 2-3 位数)，不推荐使用 |
| getFullYear() | 根据本地时间返回指定日期对象的年份（四位数年份时返回四位数字）。 |
| getMonths() | 根据本地时间返回指定日期对象的月份（0-11）。 |
| getDay() | 根据本地时间返回指定日期对象的星期中的第几天（0-6）。 |
| getDate() | 根据本地时间返回指定日期对象的月份中的第几天（1-31）。 |
| getHours() | 根据本地时间返回指定日期对象的小时（0-23）。 |
| getMinutes() | 根据本地时间返回指定日期对象的分钟（0-59）。 |
| getSeconds() | 根据本地时间返回指定日期对象的秒数（0-59）。 |
| getMilliseconds() | 根据本地时间返回指定日期对象的毫秒（0-999）。 |
| getUTCYear() getUTCFullYear() getUTCMonth() getUTC... ... | 根据世界时返回特定日期对象所在的年、月、日、时、分、秒。 |
| getTime() | 返回从1970-1-1 00:00:00 UTC（协调世界时）到该日期经过的毫秒数，对于1970-1-1 00:00:00 UTC之前的时间返回负值。 |
| getTimezoneOffset() | 返回当前时区的时区偏移。 |
| setYear() setFullYear() setMonth() ... setTime() ... setUTCYear() setUTCFullYear() setUTC... ... | 设置 Date 对象中年、月、日、时、分、秒。 |
Array
伪数组(类数组)
js
有长度有索引，但是不能使用数组的方法
字符串这种具有一部分数组特性但又不是数组的数据，统称为类数组（伪数组 Like-Array）
伪数组指的是像数组一样具有索引结构，由多个数据组成的不是数组的数据类型
二者是完全不同的两个概念， String、Arguments、NodeList、HTMLCollection 既是伪数组又是可遍历对象（ES5叫法）； Set、Map 不是伪数组是可遍历对象（ES6）。
let lis = document.querySelectorAll('li');
console.log('lis: ',lis); // 从控制台可以看到 lis 是一个数组形式，但是他的Prototype是NodeList，不是Array，所以不能使用数组的方法。① 实例的属性
js
length 获取数组的长度，元素的个数② 实例的访问器方法
执行完方法后，结算结果以返回值给出，而调用方法的对象本身不会被修改
下面的这些方法绝对不会改变调用它们的对象的值，只会返回一个新的数组或者返回一个其它的期望值。
js
concat() 将多个数组连接成一个，返回连接好的数组，参数是数组，可以是任意个
slice() 截取数组中一部分返回新数组，指定开始位置和结束位置
join() 将数组中所有的元素合并成一个字符串并返回，参数指定分隔符，默认是逗号
参数是(回调函数,[指定])
可以只写回调函数，若没有指定参数，会从数组本身的第一个元素获取数据。
若回调函数return true，满足条件，返回值，回调函数中的参数都是
item index array形式 func(item,index,array)[每一个元素][索引][数组本身]
indexOf() 返回指定元素在数组第一次出现的位置，不存在返回-1
lastIndexOf() 返回指定元素在数组最后一次出现的位置，不存在返回-1
forEach() 遍历数组，没有返回值
filter() 返回由满足复合条件的元素组成的新数组，如果回调函数返回true，与之对应的元素表示复合条件
map() 返回由回调函数的返回值组成的新数组，新数组长度与原数组一致
every() 只有每个回调函数都返回true，every方法才返回true，否则every方法返回true,空数组的every返回true
some() 只有有一个回调函数返回true，some方法就返回true
reduce() 用于累计运算，最后一次回调函数的返回值作为reduce方法的返回值
reduceRight() reduce()从左到右遍历，reduceRight从右到左遍历reduce() 方法对数组中的每个元素按序执行一个提供的 reducer 函数，每一次运行 reducer 会将先前元素的计算结果作为参数传入，最后将其结果汇总为单个返回值。
③ 实例的修改器方法
执行完方法后，调用该方法的对象本身会被修改，修改器方式是数组所独有的
下面的这些方法会改变调用它们的对象自身的值。
js
push() 在数组的后面添加元素，返回添加元素后数组的长度
unshift() 在数组的前面添加元素，返回添加元素后数组的长度
pop() 删除最后一个元素，返回被删除的元素
shift() 删除第一元素，返回被删除的元素
splice() 新增或删除，替换数组指定位置，指定数量元素（索引和长度），和元素，返回值是数组中被操作的元素
sort() 数组排序，返回排好序的数组
reverse() 翻转数组，返回翻转好的数组js
splice
插入元素
在数组末尾添加元素：array.splice(array.length, 0, newElement)
在数组开头添加元素：array.splice(0, 0, newElement)
在数组中间插入元素：array.splice(index, 0, element1, element2, ...)
删除元素
删除从指定位置开始的多个元素：array.splice(startIndex, deleteCount)
删除数组末尾的多个元素：array.splice(-count, 1)（注意这里的-count表示从数组末尾开始计数）
替换元素
替换从指定位置开始的多个元素：array.splice(startIndex, deleteCount, element1, element2, ...)
splice
作用：数组元素的增删改查
添加：arr.splice(index,0,新增的元素)
删除：arr.splice(index,删除个数)
替换：arr.splice(index,1,替换元素)js
slice()的应用
使用slice(复制一个数组
let arr5 = [1, 2, 5, 7];
let arr6 = arr5.slice(0);
console.log(arr5, arr6, arr5 === arr6); //false 引用地址不一样
// 2. 使用concat 复制数组
let arr7 = arr5.concat([]);
console.log(arr5,arr7, arr5===arr7); //false 引用地址不一样
// 3. 使用拓展运算符复制数组
let arr8 = [...arr5];
console.log(arr5, arr8, arr5===arr8); //false 引用地址不一样
slice 特殊应用，将类数组[伪]转化为普通数组
// 伪数组：有长度有索引，但是不能使用数组的方法
let lis = document.querySelectorAll('li');
console.log('lis: ',lis);
// lis.push(3); // 伪数组，不能使用数组方法
// 使用链式调用把lis中的Prototype复制成Array的
let newLis = Array.prototype.slice.call(lis);
console.log('newLis: ', newLis);
newLis.push(6)
console.log(newLis);
也可以使用Array.from()将可遍历对象或伪数组转为纯数组
const liBoxs = document.querySelectorAll('.news li');
const arr03 = Array.from(liBoxs); // [li,li,li,li,li]js
// 定义数组
var users = [
{name: '曹操', age: 67, address: '许昌'},
{name: '刘备', age: 47, address: '成都'},
{name: '孙权', age: 37, address: '南京'},
{name: '吕布', age: 51, address: '包头'},
{name: '赵云', age: 46, address: '石家庄'},
{name: '诸葛亮', age: 53, address: '南阳'}
];
console.log(users);
console.log('');
// forEach
users.forEach(function(item, index, arr) {
console.log(item, index);
});
console.log('');
// filter
// 找出年龄大于40岁的用户
var users01 = users.filter(function(item, index){
return item.age > 40;
});
console.log(users01);
console.log('');
// map
// 得到由每个用户的用户名组成的数组
var names = users.map(function(item, index) {
return item.name;
});
console.log(names);
// 让每个用户的年龄减十岁
var users02 = users.map(function(item,index) {
item.age -= 10;
return item;
});
console.log(users02);
console.log('');
// every
// 判断是否所有的用户都是成年人
var res01 = users.every(function(item,index){
return item.age >= 18;
});
console.log('判断是否所有的用户都是成年人:', res01);
// 判断是否每个用户的名字都是两个字的
var res02 = users.every(function(item) {
return item.name.length === 2;
});
console.log('判断是否每个用户的名字都是两个字的：', res02);
console.log('');
// some()
// 判断是否有住在南京的用户
var res03 = users.some(function(item,index) {
return item.address === '南京';
});
console.log('判断是否有住在南京的用户:', res03);
// 判断是否有住在上海的用户
var res04 = users.some(function(item,index) {
return item.address === '上海';
});
console.log('判断是否有住在上海的用户:', res04);
console.log('');
// reduce() 第一个参数是回调函数 第二个参数可选
// initialValue 第一次执行的回调函数没有上一次，则使用initialValue
//如果没有设置 initialValue 则使用array数组本身的第一个元素array[0]
reduce(callbackFn, initialValue)
// accumulator 上一次调用 callbackFn 的结果
//currentValue 当前元素的值
// 在第一次调用时，如果指定了 initialValue，则为 array[0] 的值，否则为 array[1]
//currentIndex currentValue 在数组中的索引位置
// 在第一次调用时，如果指定了 initialValue 则为 0，否则为 1
//array 调用了 reduce() 的数组本身
callbackFn(accumulator,currentValue,currentIndex,array){
}
/ reducer 逐个遍历数组元素，每一步都将当前元素的值与前一步的结果相加（该结果是之前所有步骤结果的总和）——直到没有更多需要相加的元素
users.reduce(function(prev, item, index, arr) {
// prev 是上一次回调函数的返回值，第一次执行的回调函数没有上一次，则使用 reduce 的第二个参数
console.log(prev, item, index);
return item.age;
});
// 计算所有用户的年龄和
var sum = users.reduce(function(prev, item) {
return prev + item.age;
}, 0);
console.log('所有用户年龄和：', sum);
/*
回调函数第一次执行 prev=0; return 57;
回调函数第二次执行 prev=57; return 57+37=94;
回调函数第三次执行 prev=94; return 94+27=121;
....
*/
// 创建数组
var nums = [12,34,12,34,545,231,1212,324];
var sum01 = nums.reduce(function(prev, item) {
return prev + item;
});
console.log('数组所有元素的和：', sum01);
console.log('');
console.log('');
users.reduceRight(function(prev, item, index) {
console.log(prev, item, index);
}, '高小乐');
/sort
sort() 方法就地对数组的元素进行排序，并返回对相同数组的引用。默认排序是将元素转换为字符串，然后按照它们的 UTF-16 码元值升序排序。
// 定义数组
const users = [
{name: '刘备', age:45, address:'上海'},
{name: '关羽', age:43, address:'苏州'},
{name: '张飞', age:41, address:'无锡'},
{name: '诸葛亮', age:44, address:'杭州'},
{name: '向华强', age:36, address:'宁波'},
{name: '曹操', age:54, address:'南京'}
];
users.sort((next,prev) => next.age - prev.age);reduce方法的使用案例
js
reduce
let nums = [{ age: 10 }, { age: 7 }, { age: 3 }];
// 需求：将年龄累加到一起
let total = nums.reduce((pre, cur, index) => {
// 次数 pre cur index return
// 1. reduce第二个参数 当前元素 当前索引 undefined
// 2. 取上一次的返回值
// 3.
// .. 最后一个次的返回值就是 reduce的返回值
return pre + cur.age
// 1 0 {age:10} return 10
// 2 10 {age:7} return 10 + 7
// 3 17 {age:3} return 17 + 3
}, 0)
console.log(total);
========================
let todoList1 = [
{
id: 1,
title: '吃饭',
isDone: true
},
{
id: 2,
title: '睡觉',
isDone: true
},
{
id: 3,
title: '学习',
isDone: true
}
]
// 需求：计算已完成代办事项的数量
let doneNum = todoList1.reduce((pre, cur) => {
// return pre + (cur.isDone ? 1 : 0)
// 等同于上边的写法：number和布尔值进行计算，布尔值会被强制转换为1或0
return pre + cur.isDone
}, 0)sort函数
compareFn(a, b) 返回值 | 排序顺序 |
|---|---|
| > 0 | a 在 b 后，如 [b, a] |
| < 0 | a 在 b 前，如 [a, b] |
| === 0 | 保持 a 和 b 原来的顺序 |
js
const stringArray = ["Blue", "Humpback", "Beluga"];
stringArray.sort(); // ['Beluga', 'Blue', 'Humpback']
const numberArray = [40, 1, 5, 200];
numberArray.sort(); // [1, 200, 40, 5]ES5 方法
| 方法名 | 含义 |
|---|---|
| forEach(callback[, thisArg]) | 为数组中的每个元素执行一次回调函数，用于数组遍历 |
| filter(callback[, thisArg]) | 将所有在过滤函数中返回 true 的数组元素放进一个新数组中并返回，用于数组过滤。 |
| map(callback[, thisArg]) | 返回一个由回调函数的返回值组成的新数组。 |
| every(callback[, thisArg]) | 如果数组中的每个元素都满足测试函数，则返回 true，否则返回 false。 |
| some(callback[, thisArg]) | 如果数组中至少有一个元素满足测试函数，则返回 true，否则返回 false。 |
| reduce(callback[, initialValue]) | 从左到右为每个数组元素执行一次回调函数，并把上次回调函数的返回值放在一个暂存器中传给下次回调函数，并返回最后一次回调函数的返回值。 |
| reduceRight(callback[, initialValue]) | 从右到左为每个数组元素执行一次回调函数，并把上次回调函数的返回值放在一个暂存器中传给下次回调函数，并返回最后一次回调函数的返回值。 |
| indexOf(searchElement[, fromIndex]) | 返回数组中第一个与指定值相等的元素的索引，如果找不到这样的元素，则返回 -1。 |
| lastIndexOf(searchElement[, fromIndex]) | 返回数组中最后一个（从右边数第一个）与指定值相等的元素的索引，如果找不到这样的元素，则返回 -1。 |
Function
Function 是所有函数的构造函数，Function 也是自己的构造函数，Function 实例的属性方法：
js
fn.length 获取形参的数量
fn.call() 调用函数并设置函数里面的this，第二个参数开始后面的参数都是给所调用的函数使用的
fn.call() call的返回值就是fn函数调用后的返回值 不指定this默认是window
fn.apply(thisArg,argument) 调用函数并设置函数里面的this，第二个参数是数组，数组中的元素作为函数的参数
// 把argument数组中的元素放在fn()的参数中
fn.bind() 永久设置函数里面的this，返回值为 永久设置this的新函数| 方法名 | 含义 |
|---|---|
| call(thisArg, arg1, arg2, ...) | 在一个对象的上下文中应用另一个对象的方法；参数能够以列表形式传入。 |
| apply(thisArg, [argsArray]) | 在一个对象的上下文中应用另一个对象的方法；参数能够以数组形式传入。 |
| bind(thisArg[, arg1[, arg2[, ...]]]) | 创建一个新的函数，这个新函数的 this 被指定为 bind() 的第一个参数 而 bind() 的其余参数将作为新函数的参数，供调用时使用。 |
.call案例
js
// 创建对象
var user = {
name: '曹操',
getInfo: func
};
// 调用函数 window调用，里面的this指向 window
func(10, 20);
user.getInfo(4, 6);
console.log('');
// 执行 func 函数类型的对象的 call 方法； 函数会被调用
// call 调用 func的同时可以设置里面的 this
var res = func.call({name:'高小乐'}, 10, 6);
user.getInfo.call([10,20,30], 8, 5);
console.log(res);
console.log('');.call案例2
js
// 使用 forEach 遍历字符串
var str = 'Hello高小乐';
// Array.prototype.forEach(function(){}); forEach系统默认遍历的是this
[].forEach.call(str, function(item,index, arr){
console.log(item, index);
});
console.log('');
var str1 = [].reduceRight.call(str, function(prev, item){
return prev + item
});
console.log(str1);
console.log('');js
var str1 = [].reduceRight.call(str, function(prev, item){
return prev + item
});
console.log(str1);.bind案例
js
function func(num01, num02) {
console.log('func被调用了：', num01*num02, this);
return num01+num02;
};
var fn01 = func.bind([10,20,30,40,50]); //第一个参数 设置函数fn01里的this 永久为数组
console.log(fn01(10, 20));
console.log('');
// 函数科里化
var fn02 = func.bind([10,20,30], 10000); //第二个参数 设置函数fn02中第一个参数的值，以此类推
console.log(fn02(2)); //函数调用，传入参数，设置函数fn02中的第二个参数的值。
console.log('');
var fn03 = func.bind([10,20,30], 100, 200);
console.log(fn03());call和bind的区别
js
bindcall的主要区别在于执行方式和this的修改方式
执行方式不同：call和apply是立即执行的，它们会调用函数并立即执行，而bind则不会立即执行，它返回一个新的函数，这个新函数的this被绑定到了指定的对象上，只有在调用这个新函数时，才会执行原函数
this的修改方式不同：call和apply只是临时的修改一次this指向，即它们只在调用时修改一次this，当再次调用原函数时，this指向会恢复到原来的指向。而bind则是永久修改函数this指向，它返回一个新的函数，这个新函数的this永远被改变了，绑定了就修改不了示例
js
function foo(a, b) {
console.log(this.x + a + b);
}
var obj1 = {x: 1};
var obj2 = {x: 2};
// 使用call方法
foo.call(obj1, 3, 4); // 输出：1 + 3 + 4 = 8，因为call会立即执行函数，并且临时修改this指向obj1
// 使用apply方法
foo.apply(obj2, ); // 输出：2 + 5 + 6 = 13，因为apply会立即执行函数，并且通过数组参数修改this指向obj
// 使用bind方法
var boundFoo = foo.bind(obj1, 3, 4); // boundFoo是一个新的函数，它的this被永久绑定到obj1，并且预填充了参数3和4
boundFoo(); // 输出：1 + 3 + 4 = 8，因为只有当我们调用boundFoo时，才会执行函数，并且this指向obj1JSON
JSON 对象的方法
| 方法名 | 含义 |
|---|---|
| JSON.parse() | 解析JSON字符串并返回对应的值。将对象或数组转为json格式的字符串 |
| JSON.stringify() | 返回与指定值对应的JSON字符串。将json格式的字符串 恢复成对象或数组 |
json 数据格式
1）json（ JavaScript Object Notation）是一种前后端数据交互的数据格式。
2）json本质上是一个字符串，简称json串。
json
{
"paramz": {
"feeds": [
{
"id": 299076,
"oid": 288340,
"category": "article",
"data": {
"subject": "汉东新闻2.0：不止是阅读",
"summary": "汉东广电旗下资讯类手机应用“汉东新闻”于近期推出全新升级换代的2.0版。",
"cover": "/Attachs/Article/288340/3e8e2c397c70469f8845fad73aa38165_padmini.JPG",
"pic": "",
"format": "txt",
"changed": "2019-09-22 10:01:42"
}
}
],
"PageIndex": 1,
"PageSize": 20,
"TotalCount": 53521,
"TotalPage": 2677
}
}注意：
json 格式参照 JavaScript 对象、数组的语法，但有些不同，如 ：
① json 中属性名称必须是双引号括起来的字符串，最后一个属性后不能有逗号。
② json 中字符串必须用双引号括起来。
json的属性值可以是对象，字符串，数组，基本数据类型等等。
全局对象的方法
全局对象的方法别名（全局函数）
全局对象 （global object） 是可以在全局作用域里，通过this访问（但只有在 ECMAScript 5 的非严格模式下才可以，在严格模式下得到的是 undefined）。在浏览器端，全局对象就是 window 对象。
全局的对象（ global objects ）或称标准内置对象，不要和 "全局对象（global object）" 混淆。这里说的全局的对象指的是全局对象的属性。全局对象的属性都在全局作用域中。
属性
| 属性名 | 含义 |
|---|---|
| NaN | 一个 number 类型的值，Not-A-Number。 |
| Infinite | 一个number类型的值，表示无穷大。 |
方法
| 方法名 | 含义 |
|---|---|
| eval(string) | 会将传入的字符串当做 JavaScript 代码进行执行。 |
| encodeURI() | 通过将特定字符的每个实例替换为一个、两个、三或四转义序列来对统一资源标识符 (URI) 进行编码 |
| decodeURI() | 函数能解码由 encodeURI() 创建或其它流程得到的统一资源标识符（URI） |
| isNaN() | 确定一个值是否为 NaN。 |
| isFinite() | 判断一个数是否是有限数值。 |
| parseInt() | 从字符串中提取整数。 |
| parseFloat() | 从字符串中提取浮点数。 |
ECMAScript 标准中规定了一个全局对象 Global，像 Array、Number、 String、isNaN、isFinite 等都是 Global 的属性。
浏览器上存在 window 对象，向alert、prompt 等都是 window 的属性，运行在浏览器上的 JS，Global 就是 window。
js
eval() 参数是字符串，将字符串作为代码执行
encodeURI() 对URL进行编码
decodeURI() 对编码后的URL进行解码toString
javascript中的toString()方法，主要用于Array、Boolean、Date、Error、Function、Number等对象。下面是这些方法的一些解析和简单应用，做个纪律，以作备忘。
1 arr.toString()：将数组转换成一个字符串，并且返回这个字符串。
2 b.toString()：将布尔值转换为字符串。
3 Date.toString()：将Date对象转换成一个字符串，采用本地时间。
4 Error.toString()：将Error对象转换成字符串
5 Function.toString()：把函数转换成字符串，函数是什么样就返回什么样
6 Number.toString()：将数字转换为字符串。用它的参数指定的基数或底数（底数范围为2-36）。如果省略参数，则使用基数10。当参数值为2时，返回二进制数
案例
①字符串转换
js
/**
* 字符串转换 将短横线分隔的字符串转为小驼峰的形式
* @params {string} 要转换的字符串
* @returns {string} 转化好的字符串
*/
function toCamel(str) {
return str.split('-').map(function(item, index) {
return index === 0 ? item.toLowerCase() : item[0].toUpperCase() + item.slice(1).toLowerCase();
}).join('');
}
console.log(toCamel('get-element-by-id'));
console.log(toCamel('set-name-by-class-name'));
// 实现思路二 ----------------------------------------------------------------
// 定义字符串
var str = 'get-element-by-id';
// 使用 map 进行处理
var newStr = str.split('-').map(function(item, index) {
return index === 0 ? item.toLowerCase() : item[0].toUpperCase() + item.slice(1).toLowerCase();
}).join('');
console.log(newStr);
// 实现思路一 ----------------------------------------------------------------
// 定义字符串
var str = 'get-element-by-id';
// 将字符串分割成数组
var arr = str.split('-');
var newStr = '';
// 遍历数组
arr.forEach(function(item, index) {
if (index === 0) {
newStr += item.toLowerCase();
} else {
newStr += (item[0].toUpperCase() + item.slice(1).toLowerCase());
}
});
console.log(newStr);②封装函数
js
// 创建字符串
// var str = 'Hello，高小乐';
// console.log(str.split('').reverse().join(''));
/**
* 翻转字符串
* @params {string} 要处理的字符串
* @returns {string} 翻转好的字符串
*/
function reverseString(str) {
return str.split('').reverse().join('');
}
console.log(reverseString('Hello,高小乐'));
console.log(reverseString('Hello,World'));③封装函数
js
/**
* 随机取数组中的一个元素
* @params {array} 数组
* @returns 随机取出来的元素
*/
function randomArray(arr) {
// 得到随机整数 范围0 ~ arr.length-1
return arr[Math.floor(Math.random() * arr.length)];
}
console.log(randomArray(['刘姥姥', '牛姥姥', '司马姥姥', '欧阳姥姥', '独孤姥姥', '令狐姥姥', '东方姥姥']));④输出当前日期时间
js
// 创建日期时间对象
var date = new Date();
// 分别获取年月日时分秒
var y = date.getFullYear();
var m = date.getMonth() + 1;
var d = date.getDate();
var h = date.getHours();
var i = date.getMinutes();
var s = date.getSeconds();
// 个位数补 0
m = m < 10 ? '0' + m : m;
d = d < 10 ? '0' + d : d;
h = h < 10 ? '0' + h : h;
i = i < 10 ? '0' + i : i;
s = s < 10 ? '0' + s : s;
// 拼接日期时间字符串
console.log(y+'-'+m+'-'+d+' '+h+':'+i+':'+s);