Javascript分三种对象：自定义对象、内置对象、浏览器对象
前两种对象是JS基础内容，属于ECMAScript；第三个浏览器对象属于我们JS独有的。
内置对象： 就是指JS语言自带的一些对象，这些对象供开发者使用，并提供了一些常用的或是最基本而必要的功能（属性和方法）
常用的Math对象
Math对象不是构造函数，它具有数学常数和函数的属性和方法。跟数学相关的运算（求绝对值，取整，最大值等）可以使用Math中的成员。
| Math.PI | 圆周率 |
| Math.floor() | 向下取整 |
| Math.ceil() | 向上取整 |
| Math.round() | 四舍五入 就近取整 |
| Math.abs() | 绝对值 |
| Math.max()/Math.min() | 求最大值和最小值 |
// 函数封装自己的数学方法 模仿Math内部
// var myMath = {
// PI: 3.141592653,
// max: function() {
// var max = arguments[0];
// for (var i = 1; i <= arguments.length; i++) {
// if (arguments[i] > max) {
// max = arguments[i];
// }
// }
// return max;
// },
// min: function() {
// var min = arguments[0];
// for (var i = 1; i <= arguments.length; i++) {
// if (arguments[i] < min) {
// min = arguments[i];
// }
// }
// return min;
// }
// }
// console.log(myMath.PI);
// console.log(myMath.max(1, 4, 6, 8));
// console.log(myMath.min(1, 4, 6, 8));
// 绝对值方法
console.log(Math.abs(1)); // 1
console.log(Math.abs(-1)); // 1
console.log(Math.abs('-1')); // 隐式转换 把字符串 -1 转换为数字型
console.log(Math.abs('pink')); // NaN
// 三个取整数方法
// (1)Math.floor() 地板 向下取整 往最小了取值
console.log(Math.floor(1.1)); // 1
console.log(Math.floor(1.9)); // 1
// (2)Math.ceil() 天花板 向上取整 往最大了取值
console.log(Math.ceil(1.9)); // 2
console.log(Math.ceil(1.9)); // 2
// (3)Math.round() 四舍五入 其他数字都是四舍五入，但是 .5 特殊 它往大了取值
console.log(Math.round(1.1)); // 1
console.log(Math.round(1.5)); // 2
console.log(Math.round(1.9)); // 2
console.log(Math.round(-1.1)); // -1
console.log(Math.round(-1.5)); // 这个结果是-1
// 1.Math对象随机数方法， random() 返回一个随机的小数 0 =< x < 1
// 2.这个方法里不跟参数
// 3.代码验证
console.log(Math.random());
// 4.得到两个数字之间的随机整数， 并且 包含这两个数
function getRandom(min, max) {
return Math.floor(Math.random() * (max - min + 1)) + min;
}
console.log(getRandom(1, 10));
// 5.随机点名
var arr = ['小明', '小红', '小白', '小李'];
console.log(arr[getRandom(0, arr.length - 1)]);
// 猜数字
// 1.随机生成一个1~10之间的整数
// 2.需要一直猜到正确数字，所以需要一直循环
// 3.while 循环
// 4.核心算法：使用 if else if 多分支语句来判断大于，小于，等于
function getRandom(min, max) {
return Math.floor(Math.random() * (max - min + 1) + min);
}
var random = getRandom(1, 10);
while (true) {
var num = prompt('猜1~10之间的整数');
if (num > random) {
alert('猜大了！')
} else if (num < random) {
alert('猜小了！');
} else {
alert('猜对了！');
break;
}
}
常用的Data对象
日期格式化
| 方法名 | 说明—代码 |
|---|---|
| getFullYear() | 获取当前年份 Obj.getFullYear() |
| getMonth() | 获取当前月份 Obj.getMonth() |
| getDate() | 获取当前日期 Obj.getDate() |
| getDay() | 获取星期几(周日0到周六6） Obj.getDay() |
| getHours() | 获取当前小时 Obj.getHours() |
| getMinutes() | 获取当前分钟 Obj.getMinutes() |
| getSeconds() | 获取当前秒钟 Obj.getSeconds() |
// Date（）日期对象 是一个构造函数，必须使用new 来调用 创建日期对象
var arr = new Array(); // 创建一个数组对象
var obj = new Object(); // 创建一个数组对象
// 1.使用Date 如果没有参数，返回系统的当前时间
var date = new Date();
console.log(date);
// 2.参数常用的写法 数字型 2019, 10, 01 或者 字符串型 '2019-10-1 8:8:8'
var date1 = new Date(2019, 10, 1);
console.log(date1);
var date2 = new Date('2019-10-1 8:8:8');
console.log(date2);
// 格式化日期 年月日
var date = new Date();
console.log(date.getFullYear()); // 返回当前年份 2021
console.log(date.getMonth() + 1); // 返回月份 返回的月份小 1 个月 记得月份 + 1
console.log(date.getDate()); // 返回的是 几号
console.log(date.getDay()); // 周日返回的是 0 ，周一返回 1 周六返回 6
console.log(date.getHours()); // 小时
console.log(date.getMinutes()); // 分钟
console.log(date.getSeconds()); // 秒中国
// 写一个2021年 3月 26日 星期五
var year = date.getFullYear();
var month = date.getMonth() + 1;
var dates = date.getDate();
var day = date.getDay();
var arr = ['星期日', '星期一', '星期二', '星期三', '星期四', '星期五', '星期六', ]
console.log(year + '年' + month + '月' + dates + '日 ' + arr[day]);
// 格式化时分秒
// 要求封装一个函数返回当前的时分秒 格式 08：08：08
function getTime() {
var time = new Date();
var hours = date.getHours();
hours = hours < 10 ? '0' + hours : hours;
var minutes = date.getMinutes();
minutes = minutes < 10 ? '0' + minutes : minutes;
var seconds = date.getSeconds();
seconds = seconds < 10 ? '0' + seconds : seconds;
return hours + ':' + minutes + ':' + seconds
}
console.log(getTime());
// 获得Date总的毫秒数（时间戳） 不是当前时间的毫秒数 而是距离1970年1月1号过了多少毫秒数
// 1.通过 valueOf() getTime()
var date = new Date();
console.log(date.valueOf()); // 获得 当前时间 距离1970.1.1 总的毫秒数
console.log(date.getTime());
// 2.简单写法（最常用的写法）
var date1 = +new Date(); // new Date() 返回就是总的毫秒数
console.log(date1);
// 3.H5 新增的 获得总的毫秒数
console.log(Date.now());
倒计时
// 倒计时案例
function conutDown(time) {
var nowTime = +new Date(); // 总的毫秒数
var inputTime = +new Date(time); // 输入的毫秒数
var times = (inputTime - nowTime) / 1000; // times 剩余时间总的毫秒数
var d = parseInt(times / 60 / 60 / 24); // 天数
var h = parseInt(times / 60 / 60 % 24); // 小时
var m = parseInt(times / 60 % 60); // 分钟
var s = parseInt(times % 60); // 秒钟
d = d < 10 ? '0' + d : d;
h = h < 10 ? '0' + h : h;
m = m < 10 ? '0' + m : m;
s = s < 10 ? '0' + s : s;
return d + '天 ' + h + '：' + m + '：' + s;
}
console.log(conutDown('2021-4-1 18:00:00'));
常用的Array对象
拼接数组 + 截取数组
// 创建数组的两种方式
// 1.利用数组字面量
var arr0 = [1, 2, 3];
console.log(arr0[0]);
// 2.利用new Array()
var arr1 = new Array(); // 创建了一个空的数组
var arr2 = new Array(2); // 表示数组的长度为 2 ，里面有两个空的数组元素
var arr3 = new Array(2, 3); // 等价于[2,3], 里面有2个数组元素 2 和 3
console.log(arr0, arr1, arr2, arr3);
// 检测是否为数组
// (1) instanceof 运算符 它可以用来检测是否为数组
var arr = [];
var obj = {};
console.log(arr instanceof Array);
console.log(obj instanceof Array);
// (2) Array.isArray(参数) H5新增的方法， ie9以上版本支持
console.log(Array.isArray(arr));
console.log(Array.isArray(obj));
// 添加或删除数组元素
// 1. push() 在数组末尾 添加一个或多个数组元素 push
var arr = [1, 2, 3];
console.log(arr.push(4, 'pig'));
console.log(arr);
// (1) push是可以给数组追加新的元素
// (2) push() 参数直接些数组元素就可以了
// (3) push 完毕后，返回结果是 新数组的长度
// (4) 原数组也会发生变化
// 2. unshift 在数字开头 添加一个或多个数组元素
console.log(arr.unshift('red'));
console.log(arr);
// (1) unshift是可以给数组追加新的元素
// (2) unshift() 参数直接些数组元素就可以了
// (3) unshift 完毕后，返回结果是 新数组的长度
// (4) 原数组也会发生变化
// 3. pop 删除数组结尾 一个 数组元素，只能删除一个
console.log(arr.unshift('red'));
console.log(arr);
// (1) pop是可以删除数组结尾 一个 数组元素
// (2) pop() 参数直接些数组元素就可以了
// (3) pop 完毕后，返回结果是 删除的数组元素
// (4) 原数组也会发生变化
// 4. shift 删除数组第一个元素
console.log(arr.unshift('red'));
console.log(arr);
// (1) shift是可以 删除数组第一个元素 只能删除一个
// (2) shift() 参数直接些数组元素就可以了
// (3) shift 完毕后，返回结果是 删除的数组元素
// (4) 原数组也会发生变化
// 筛选数组
var arr = [1500, 1200, 2000, 2100, 1800];
function getSum() {
var newArray = [];
for (var i = 0; i <= arr.length; i++) {
if (arr[i] > 2000) {
newArray.push(arr[i]);
}
}
return newArray;
}
console.log(getSum());
// 数组排序
// 1.翻转数组
function getArr() {
var arr = ['pink', 'red', 'blue'];
arr.reverse();
return arr;
}
console.log(getArr());
// 2.数组排序 (冒泡排序)
// sort方法 单独使用 只能够排序个位数的数组
function getNewArr() {
var arr = [3, 14, 6, 1];
arr.sort(function(a, b) {
// return a - b; 升序的顺序排序
return b - a; // 降序的顺序排序
});
return arr
}
console.log(getNewArr());
// 返回数组元素数组索引的方法 indexOf(数组元素) 作用返回该数组元素的索引号 从 前 面开始查找
var arr = ['red', 'green', 'blue', 'pink', 'blue'];
// 只返回第一个满足条件的数组元素的索引号
console.log(arr.indexOf('blue')); // 2
// 如果在该数组找不到该元素 则返回 -1
console.log(arr.indexOf('black')); // -1
// lastIndexOf(数组元素) 作用返回该数组元素的索引号 从 后 面开始查找
console.log(arr.lastIndexOf('blue')); // 4
// 数组去重
var arr = ['a', 'b', 'c', 'c', 'd', 'd', 'e', 'f'];
function getArrs(arr) {
var newArr = [];
for (var i = 0; i < arr.length; i++) {
if (newArr.indexOf(arr[i]) === -1) {
newArr.push(arr[i]);
}
}
return newArr;
};
console.log(getArrs(arr));
// 数组转换为字符串
// 1.tostring()
var arr = [1, 2, 3];
console.log(arr.toString());
// 2.join(分隔符)
console.log(arr.join('-'));
console.log(arr.join('&'));
// concat 拼接数组
var newArr = ['a', 'b', 'c'];
console.log(arr.concat(newArr));
// splice 截取数组
console.log(newArr.splice(0, 2));
常用的String对象
// 基本包装类型： 就是把简单数据类型 包装 成复杂数据类型， 这样简单数据类型就有了属性和方法
var str = 'andy';
console.log(str.length);
// 按道理简单数据类型是没有 属性 和 方法的，而对象才有 属性 和 方法 ， 但上面的代码却可以执行，这是因为js会把简单数据类型 包装 成复杂数据类型 其执行过程如下：
// 1.生成临时变量，把简单数据类型包装为复杂数据类型
var temp = new String('andy');
// 2.赋值给我们声明的字符变量
str = temp;
// 3.销毁临时变量
temp = null;
// ---------------------------------------------------------------------------------
// 字符串的不可变 指在内存中新开辟了一块空间，变量的指向改变到新的字符串
var str = 'abc';
str = 'hello';
// 当重新赋值时，常量 'abc' 不会被修改 还存在内存中
// 重新给字符串 赋值，在内存中新开辟了一块空间，这个特点就是字符串的不可变
// 由于字符串的不可变，在大量拼接字符串时会有效率问题
// var str = '';
// for (var i = 1; i <= 100000; i++) { str += i; }
// console.log(str); 这个结果需要花费大量时间来显示，因为需要不断的开辟空间
// 字符串所有的方法，都不会修改字符串本身，操作完成会返回一个新的字符串(在内存开辟新的空间)
// ------------------------------------------------------------------------------------
// 根据 字符 返回 位置 str.indexOf('要查找的字符'，[起始位置])
var str = '哔哩哔哩-西里西里';
console.log(str.indexOf('哩')); // 1
console.log(str.indexOf('西', 6)); // 7 从索引号6 的位置开始往后查找
// 返回字符位置---查找字符中所有 o 出现的位置以及次数
var str = 'abcsdcodfofdsfo';
var index = str.indexOf('o'); // 获得 o 第一次出现的 索引号
var num = 0; // 声明 o 出现的次数
while (index != -1) {
console.log(index); // o != -1 输出 6
num++; // 每输出一次 o 的位置， num + 1
index = str.indexOf('o', index + 1); // 从 6+1 开始查找 o ，并赋值给 index = 9
}
console.log('o 出现的次数是：' + num);
// ------------------------------------------------------------------------------------
// 根据 位置 返回 字符
// 1.charAt(index) 根据位置返回字符
var str = 'andy';
console.log(str.charAt(3));
// 遍历所有字符
for (var i = 0; i <= str.length - 1; i++) {
console.log(str.charAt(i));
};
// 2.charCodeAt(index) 返回相应索引号的字符ASCII值 目的：判断用户按下那个键
console.log(str.charCodeAt(0)); // 键盘 a 的ASCII值为 97;
// 3.str[index] H5 新增的
console.log(str[0]); // a
// 返回字符位置---查找字符中出现次数最多的字符，并统计次数
// 利用chartAt()遍历字符串；
// 把每个字符串都储存给对象，如果对象没有该属性，就为1，如果存在就 +1
// 遍历对象，得到最大值和该字符串
var str = 'abcsdcodfofdsfoo';
var o = {};
for (var i = 0; i <= str.length; i++) {
var chars = str.charAt(i);
if (o[chars]) {
o[chars]++;
} else {
o[chars] = 1;
}
}
console.log(o);
// 遍历对象 for in
var max = 0;
var ch = '';
for (var k in o) {
// k 得到属性名
// o[k] 得到里面的属性值
if (o[k] > max) {
max = o[k];
ch = k;
}
}
console.log('次数最多字符' + ch);
console.log('最多次数' + max);
// ------------------------------------------------------------------------------------
// 字符串操作方法
// 1.concat('字符串1','字符串2'...) 拼接字符串
var str = 'andy';
console.log(str.concat('Marvin'));
// 2.substr('截取起始位置(索引号)','截取字符个数');
console.log(str.substr(2, 2));
// 3.替换字符串 replace('被替换字符','替换后的字符') 只替换第一个字符
console.log(str.replace('a', 'A'));
// 替换所有字符串 中 所有 o
var str1 = 'abcsdcodfofdsfoo';
while (str1.indexOf('o') !== -1) {
str1 = str1.replace('o', '***');
}
console.log(str1);
// 4.字符串转换为数组 split('分隔符') 取决于 字符串 用什么符号隔开的, 字符串连接在一起，只能转换为一个数组元素
var strs = '1,3,4'
console.log(strs.split(','));
// 5.转行大写
var str = 'andy';
console.log(str.toUpperCase());
var str = 'ANDY';
// 6.转行小写
console.log(str.toLowerCase());
119
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
