1.const必须保证变量指向地址不变
const obj={
type:"success",
message:"kakaxi",
trigger:'blur'
}
obj.type='err' //可以修改对象属性
obj.duration:'1000' //可以添加对象属性
//对于复合类型的变量，变量名不指向对象，指向数据所在的地址，const必须保证变量指向地址不变，并保证该地址懂得数据不变
//无法重新为常量赋值
obj={
type:"error",
message:"defeated",
trigger:'blur'
}
2.类型转换
//parseInt()转整数 开头必须是数字
parseInt(10.2)//10
parseInt('12dsss')//12
parseInt('dd1')//NaN
parseInt('true')//NaN
//parseFloat()转小数 规则和parseInt()一样
parseFloat(10.2)//10.2
parseFloat("10adfas")//10
parseFloat('ff10.2')//NaN
//Number()转数字 必须是纯数字，布尔值可以转数字
Number('10.2')//10.2
Number('10ddd')//NaN
Number(true)//1
3.域解析
//域解析
//把变量的声明提升到当前作用域的最前面，只会提升声明，不会提升赋值
//把函数的声明提升到当前作用域的最前面，只会提升声明，不会提升调用
//先提升function，再提升var
//注:函数提升优先级比变量提升要高，且不会被变量声明覆盖，但是会被变量赋值覆盖。
var a=25;
function abc(){
console.log(a);//undefined
var a=10;
}
abc();
console.log(a);//25
var a=b=c=9;// => var a 声明a为局部变量,b=9,c=9,a=9
4.案例排他功能
var inputObj=document.getElementsByTagName("input");
for (var i=0;i<inputObj.length;i++) {
inputObj[i].onclick=function () {
// console.log(i);//5
for (var j= 0; j < inputObj.length; j++) {
inputObj[j].value="按钮";
// console.log(j);//0,1,2,3,4
}
this.value="我不是按钮";
}
}
//设置自定义属性
setAttribute()
//获取自定义属性
getAttribute()
//移除自定义属性
removeAttribute()
input autocomplete off/on 打开关闭历史记录
6.鼠标的进入离开和得到失去焦点事件
//鼠标进入离开
document.getElementById().onmouseover
document.getElementById().onmouseout
//得到失去焦点事件
document.getElementById().onfocus
document.getElementById().onblur
7.节点
//子节点
document.getElementById().childNodes
//父节点
document.getElementById().parentNode
nodeName,nodeType,nodeValue
8.创建元素
let childElement=document.creatElement('div')
document.getElementById().appendChild(childElement)
9.元素相关的方法
//把新的子元素放在第一个前面
document.getElementById().insertBefore(node,document.getElementById().firstElementChild)
//移除第一个子元素
document.getElementById().removeChild(document.getElementById().firstElementChild)
10.addEvenListener()
//元素绑定事件的引入
//参数1:事件的类型---事件的名字,没有on
//参数2:事件处理函数---函数(命名函数,匿名函数)
//参数3:布尔类型---指定事件是否在捕获或冒泡阶段执行。此参数是可选的,fasle为冒泡，true为捕获
document.getElementById().addEventListener('click',fn,false)
//移除
document.getElementById().removeEventListener('click',fn,false)
11.BOM
window.prompt() //有input对话框
window.confirm() //类似于alert()，有取消和确定选项
12.location
//地址栏上#及后面的内容
location.hash
//主机名及端口号
location.host
//主机名
location.hostname
//端口号
location.port
//文件路径---相对路径
location.pathname
//搜索内容
loaction.search
//协议
location.protocol
//页面跳转
location.herf=''
location.assign()
location.replace()//不能返回
//重新加载(刷新页面)
location.reload()
//列表中的下一个url
window.history.forward()
//列表中的上一个url
window.history.back()
//浏览器信息
window.navigator
13.一次性定时器
window.setTimeout(fn,time)
clearTimeout()
14.animate
function animate(element,target){
var timer;
//清理定时器，只产生一个定时器
clearInterval(timer)
timer= setInterval(()=>{
//移动步数
let step=8;
let current=element.offsetLeft;
step=target>current?step:-step;
current+=step;
if(Math.abs(target-current)>Math.abs(step)){
element.style.left=current+'px'
}
else{
element.style.left=target+'px';
clearInterval(timer)
}
},50)
}
15.offsetLeft
//offsetLeft:父级元素的margin+padding+border
//脱离文档流后主要是自己的left和margin
16. e.client
//e.clientX是鼠标点击的位置
document.onmousemove=function(e){
let x=e.clientX;
let y=e.clientY;
}
//css
#box1 {
width: 200px;
height: 300px;
border: 20px solid red;
border: 30px solid red;
margin: 100px 200px;
}
//普通标签的Client
let divObj = document.getElementById("box1");
divObj.clientWidth //div可视区域宽度(没有边框)，边框内部的宽度 200
divObj.clientHeight //div可视区域高度(没有边框)，边框内部的高度 300
divObj.clientLeft //左边框宽度 20
divObj.clientTop //上边框宽度 30
document.getElementById().onscroll=fn
document.getElementById().scrollTop
document.getElementById().scrollLeft
document.getElementById().scrollWidth
document.getElementById().scrollHeight
18.变速封装动画
function animate(element,target){
let timeId=setInterval(function(){
let current=element.offsetLeft
let step=(target-current)/10;
step=current>0?Math.ceil(current):Math.floor(current);
current+=step
element.style.left = current + "px";
if (current == target) clearInterval(timeId);
},50)
}
19.获取元素属性值
function getStyle(element,attr){
return window.getComputedStyle?window.getComputedStyle(element,null)[attr]:element.currentStyle[attr]
}
20.封装动画函数
function animate(element,json,fn){
var timeId= setInterval(function(){
let flag=true;
for(let attr in json){
let current=parsetInt(window.getComputedStyle(element,null)[attr]);
let target=json[attr]
let step=(target-current)/10
step=step>0?Math.ceil(step):Math.floor(step)
current+=step
element.style[attr] = current + "px";
//只有当全部flag为true时，最后一个flag才会为true
if(current!=target){
flage=false
}
}
if(flage){
clearInterval(timeId)
if(fn){
fn()
}
}
},20)
}
21.滑动
top:
window.pageYOffset
document.body.scrollTop
document.documentElement.scrollTop
left:
window.pageXOffset
document.body.scrollLeft
document.documentElement.scrollLeft
22.call和apply,bind
1.call,apply一旦调用会直接运行，bind不会
2.apply是以数组的形式传参
function Person(age,sex){
this.age=age;
this.sex=sex;
}
function Student(){
Person.call(this,18,'boy');
Person.apply(this,19,'girl');//apply传值是以数组形式传值
}
23.函数
function f1(x,y){
f1.name; //函数的名字，name属性是只读的，不能修改
f1.arguments; //实参的个数,3
f1.length; //形参的个数,2
f1.caller //调用者，此时调用者是f2
}
function f2(){
f1(1,2,3)
}
24.深拷贝
//基础数据类型变量和值都存储在栈中，引用数据类型变量存储在栈中，值存储在堆中
//引用数据类型浅拷贝是存储地址没有发生改变，指向的是同一个堆，深拷贝是新开辟了一个堆。
// 判断深拷贝还是浅拷贝，假设B复制了A，A发生了变化，B也随之发生改变，就是浅拷贝；若B没变，则是深拷贝
let obj = {
name: "婷兄",
sex: "男",
car: ["奔驰", "宝马", "奥迪"],
dog: {
name: "大黄",
age: 3,
color: "yellow"
}
}
let copyobj = {};
function extend(a, b) {
// 分三种情况
for (let key in a) {
// 1.如果是数组
if (a[key] instanceof Array) {
b[key] = [];
extend(a[key], b[key]);
}
// 2.如果是对象
else if (a[key] instanceof Object) {
b[key] = {};
extend(a[key], b[key]);
}
// 3.如果是字符串/数字
else {
b[key] = a[key];
}
}
}
extend(obj, copyobj)
obj.car.pop();
console.log(obj);
console.log(copyobj);
25.元字符
/*
[] 范围
() 分组，提升优先级
| 或者
* 0-多次
+ 1-多次
? 0-1次
{0, } 和*一样
{1, } 和+一样
{0,1} 和?一样
. 除/n以外的所有字符
\d 数字
\D 非数字
\s 空白符
\S 非空白符
\W 特殊符号
\w 非特殊符号,相当于[0-9a-zA-Z_]
^ 以什么开始; 匹配字符串的开始位置
$ 以什么结束;匹配字符串的结束位置
*/
26.创建正则表达式
let reg=new RegExp(/\d{5}/); let reg=/\d{5}/
let str="我的电话是:10086";
let flag= reg.test(str);
27.字符串使用正则表达式
//g表示全局匹配
//i忽略大小写
//1.match方法
var str = "中国移动10086，中国联通10010，中国电信10000";
let arr=str.match(/\d{5}/g);
// ["10086", "10010", "10000"]
//2.$使用
//$ 匹配到的值，如果未匹配到，则为空值;使用$number表示;如一下就有3个$
var now = "2021-01-03";
arr = now.match(/(\d{4})[-](\d{2})[-](\d{2})/g);
console.log(RegExp.$1,RegExp.$2,RegExp.$3);//2021 01 03
//3.replace
let res="动态规划的使用动";
res.replace(/动/g,"静")
//4.去空格
let str="字符串 使用 正则表达式";
str.replace(/\s/g,"")
//5.大小写替换
let str="niShuosha";
str.replace(/[s]/gi,"w")
28.正则表达式方法
var str = "中国移动10086，中国联通10010，中国电信10000";
var reg=/\d{5}/g;
//通过正则表达式匹配这个字符串
var arr= reg.exec(str);
//arr[0]就是匹配到的值，多次使用reg.exec()会一直截取字符串匹配，直到结束，结束输出为null
29.元素获取方式
//根据ID属性值获取元素，返回来的是一个元素对象
//document.getElementById("id属性的值");
//根据标签名获取元素，返回来的是一个维数组，里面保存了多个DOM对象
//document.getElementsTagName("标签名字")
//以下几个有的浏览器不支持
//根据name属性获取元素，返回来的是一个维数组，里面保存了多个DOM对象
//document.getElementByName("name属性的值")
//根据类样式的名字获取元素，返回来的是一个维数组，里面保存了多个DOM对象
//document.getElementsByClassName("类样式的名字")
//根据选择器获取元素，返回来的是一个元素对象
//document.querySelector("选择器的名字);
//根据选择器获取元素，返回来的是一个伪数组，里面保存了多个DOM对象
//document.querySelectorAll("选择器的名字")
30.进制的转换
//十进制转其他进制
let num1=110;
//转二进制
num1.toString(2)
//转八进制
num1.toString(8)
//其他进制转十进制
let num2=110;
//二进制转十进制
parseInt(num2,2)
31.字符串和数组之间的转换
//字符串转数组
let str="abcdef";
let arr= str.split("");
//数组转字符串
str= arr.join('')
32.保留小数点后面数
num.toFixed(2)
num.toPrecision(2)
33.innerText和textContent,innerHTML
//innerText和TextContent都是改变标签内文本内容
//innerHTML可以
34.子元素和子节点
my$("box1").children[0] //子元素
my$("box1").childrenNodes[0] //子节点，第一个节点为文本(text)
35.对象三种方法
function People(name) {
this.name = name;
//对象方法
this.Introduce = function () {
alert("My name is " + this.name);
}
}
//类方法
People.Run = function () {
alert("I can run");
}
//原型方法
People.prototype.IntroduceChinese = function () {
alert("我的名字是" + this.name);
}
//测试
var p1 = new People("Windking");
p1.Introduce();
People.Run();
p1.IntroduceChinese();
36.原型链
//实例对象与原型对象之间的关系,通过__proto__联系
person.__proto__===Person.prototype //true
37.this指向
var name = "winname";
var obj = {
name: " funname",
fn: function () {
console.log(this.name);
}
}
var res = obj.fn;
res();//winname //是在window下
obj.fn();//funname
function f1() {
this.name = "html";
this.f2 = function () {
return function () {
return this.name;
}
}
}
let f = new f1();
console.log(f.f2()());//winname
38.querySelectAll()和getElementsByTagName()
// 通过QSA选择的不受后来DOM变化的影响，但是通过GEBC会受DOM的影响。
a = document.querySelectorAll('img');
b = document.getElementsByTagName('img');
document.body.appendChild(new Image());
console.log(a.length) // 0
console.log(b.length) // 1
39.append和appendChild
//1、querySelector只返回匹配的第一个元素，如果没有匹配项，返回null。
let divObj = document.querySelector("div");
let newdiv = document.createElement("div");
divObj.appendChild(newdiv);//只能传节点(node),不能传字符串,会返回一个节点
divObj.append("div");//能传字符串和节点,只是一个方法，不会有返回值
40.classList
//添加类
document.getElementById("myDIV").classList.add("mystyle");
//去除类
document.getElementById("myDIV").classList.remove("mystyle");
41.ES6交换变量的值
//数组解构赋值
var a = 2, b = 4;
[a, b] = [b, a];
console.log(a, b);
42.for..in和for..of
//非枚举属性
Array.prototype.newArr = () => { };
Array.prototype.anotherNewArr = () => { };
const array = ['foo', 'bar', 'baz'];//枚举属性
for (const value in array) {
console.log(value);
}
// Outcome:
// 0
// 1
// 2
// newArr
// anotherNewArr
// for...in 不仅枚举上面的数组声明，它还从构造函数的原型中查找继承的非枚举属性，
// 在这个例子中，newArr 和 anotherNewArr 也会打印出来。
for (const value of array) {
console.log(value);
}
// Outcome:
// foo
// bar
// baz
// for...of 不会输出非枚举属性
43.hasOwnProperty()
//Object的hasOwnProperty()方法返回一个布尔值，判断对象是否包含特定的自身（非继承）属性。
function foo() {
this.name = 'foo'
this.sayHi = function () {
console.log('Say Hi')
}
}
foo.prototype.sayGoodBy = function () {
console.log('Say Good By')
}
let myPro = new foo()
console.log(myPro.name) // foo
console.log(myPro.hasOwnProperty('name')) // true
console.log(myPro.hasOwnProperty('toString')) // false
console.log(myPro.hasOwnProperty('hasOwnProperty')) // fasle
console.log(myPro.hasOwnProperty('sayHi')) // true
console.log(myPro.hasOwnProperty('sayGoodBy')) // false
console.log('sayGoodBy' in myPro) // true
44.object.keys()
//参数：要返回其枚举自身属性的对象
// 返回值：一个表示给定对象的所有可枚举属性的字符串数组
// 处理对象，返回可枚举的属性数组
// let person = { name: "张三", age: 25, address: "深圳", getName: function () { } }
// let res = Object.keys(person) // ["name", "age", "address","getName"]
45.Object.getPrototype()
// Object.getPrototypeOf()该方法返回指定对象的原型
function Student() {
}
Student.prototype.study = function () {
console.log(this);
}
Student.prototype.play=function(){
console.log("play xixi")
}
let stu=new Student();
console.log(Object.getPrototypeOf(stu)===Student.prototype); //true
46.Object.creat()和new Object
// Object.cerate() 必须接收一个对象参数，创建的新对象的原型指向接收的参数对象，
// new Object() 创建的新对象的原型指向的是 Object.prototype.
// （表述有点啰嗦，简洁点说就是前者继承指定对象 后者继承内置对象Object）
// 可以通过Object.create(null) 创建一个干净的对象，也就是没有原型，
// 而 new Object() 创建的对象是 Object的实例,原型永远指向Object.prototype
47.Reflect.ownKeys()和Object.keys()
// 总结：
// Object.keys()主要用于遍历对象自有的可枚举属性，不包括继承自原型的属性和不可枚举的属性。
// Reflect.ownKeys()返回所有自有属性key，不管是否可枚举，但不包括继承自原型的属性
var obj = {}
Object.defineProperty(obj, 'method1', {
value: function () { //value:该方法(method1)的值,可以调用
alert("Non enumerable property");
},
enumerable: false
})
console.log(Object.keys(obj)); // []
console.log(Reflect.ownKeys(obj)); // ["method1"]
48.Number.isInteger()
//判断是否是整数
Number.isInteger(100)
49.rest参数
//将传递值转换成数组
function add(...value) {
console.log(value);
}
add(1,2);
50.Object.defineProperty()
var a={};
Object.defineProperty(a,"b",{
set(newValue){
console.log("你要赋值给我，我的新值是"+newValue);
},
get(){
console.log("你去我值？");
return 2;//注意这里，我硬是让他返回2
}
});
a.b=1;
console.log(a.b);
51.Object.getOwnPropertyNames()
//Object.getOwnPropertyNames返回的是对象所有自己的属性，
//而Object.keys(obj)则返回的是所有可枚举属性，也就是属性下的enumerable: false
52.键盘按下事件
document.querySelector("#testkeyevent").addEventListener('keydown', function (e) {
console.log(e.keyCode);
});
53.getComputedStyle()和element.style
// getComputedStyle能直接获取css里面的值，element.style只能获取在js里面设置的值,更倾向于设置值
54.鼠标事件
let d = document.documentElement;
//1.鼠标点击事件，多用在某个对象控制的范围内的鼠标点击
// d.onclick = function () {
// console.log("onclick");
// }
// 2.鼠标双击事件,同时会触发两次点击事件
// d.ondblclick = function () {
// console.log("ondbclick");
// }
//3.鼠标上的按钮被按下了
// d.onmousedown = function () {
// console.log("onmousedown");
// }
//4.鼠标抬起事件
// d.onmouseup = function () {
// console.log("onmouseup");
// }
//5.当鼠标移动到某对象范围的上时触发的事件
// document.querySelector("div").onmouseover=function(){
// console.log("onmousover");
// }
//6.鼠标移动时触发的事件
// document.querySelector('div').onmousemove=function(){
// console.log("onmousemove");
// }
//7.当鼠标离开某对象范围时触发的事件
// document.querySelector("div").onmouseout = function () {
// console.log("onmouseout");
// }
// 8.当键盘上的某个键被按下并且释放时触发的事件.[注意:页面内必须有被聚焦的对象]
//当用户在输入框内按下一个按键时函数被触发
// document.querySelector("input").onkeypress = function () {
// alert("onkeypress")
// }
// 9.当键盘上某个按键被按下时触发的事件[注意:页面内必须有被聚焦的对象]
// document.querySelector("input").onkeydown = function () {
// alert("onkeydown")
// }
//10.当键盘上某个按键被按放开时触发的事件[注意:页面内必须有被聚焦的对象]
document.querySelector("input").onkeyup=function(){
alert("onkeyup");
}
55.闭包
function f1() {
var n = 999;
nAdd = function () {
n += 1;
}
function f2() {
console.log(n);
}
return f2;
}
var result = f1();
result(); // 999
nAdd();
result(); // 1000
var name = "The Window";
var object = {
name: "My Object",
getNameFunc() {
// 闭包
return function () {
return this.name;
};
}
};
console.log(object.getNameFunc()());//The window
56.进制
//二进制0b开头,八进制0o开头,十六进制0x开头
console.log(0b11);
console.log(0o11);
console.log(0x11);
57.阻止事件冒泡
//事件冒泡：从内向外
myTest("div1").onclick = function (e) {
console.log(this.id);
// e.stopPropagation(); 阻止事件冒泡
// return false js阻止事件默认行为jQuery阻止事件冒泡和默认行为
// e.preventDefault 阻止默认行为
};
58.indexOf
let str = "/public/css/main.css";
console.log(str.indexOf("/public/"),str.leng);//0 2-
59.使用for..of输出对象
// NodeList.prototype[Symbol.iterator] = Array.prototype[Symbol.iterator];
let arr = [12, 22, 13, 44, 32];
let obj = {
0: 'String',
1: true,
2: 12,
length: 3,
[Symbol.iterator]: Array.prototype[Symbol.iterator]
}
//输出索引
// for (let item in obj) {
// console.log(item);
// }
//输出值,输出该对象报错
for (let item of obj) {
console.log(item);
}
60.无法选中文本
document.onselectstart=function(){
return false;
}
61.vue中的this指向
var vm = new Vue({
el: '#container',
data: {
age: 18,
},
methods: {
f2() {
console.log(this); //vm
return function () {
console.log(this); //window
}
}
},
created() {
console.log(this);//vm
function f1() {
console.log(this);//window
}
f1();
this.f2()();
},
});
62.with
let obj = {
name: "ting",
age: 20,
sex: "女"
};
with (obj) {
name = "yang";
age = 18;
sex = "女";
}
console.log(obj.name, obj.age);//yang 18
63.复制变量值
//基本数据类型保存在栈内存中
//从一个变量复制另一个变量的值，会创建这个值的副本
var num1=10;
var num2=num1;
//引用类型的值是对象，保存在堆内存中
//从一个变量复制另一个变量的值，复制的其实是指针，因此两个变量最终指向同一个对象
var obj1=new Object();
var obj2=obj1;
obj1.name="nbplus";
console.log(obj2.name);
64.数组迭代器
let numbers = [1, 2, 4, 6];
const isEven = x => x % 2 === 0;
//使用every方法迭代，迭代每个元素，直到返回false
console.log(numbers.every(isEven));
//使用some方法迭代，迭代每个元素，直到返回true
console.log(numbers.some(isEven));
//使用foreach方法迭代输出每个数组的值 (value,index,arr)
numbers.forEach(x => console.log(x % 2 === 0));
//使用map方法迭代，迭代每个元素，返回每个元素的 Boolean值
console.log(numbers.map(isEven));
//使用filter方法迭代,返回的元素由true元素组成
console.log(numbers.filter(isEven));
let nums=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
nums.filter((num)=>num>5);
//使用reduce方法迭代，对一个数组中的所有元素求和
console.log(numbers.reduce((previous, current) => previous + current));
65.函数声明与函数表达式
num();//xixi
res();//报错
function num(){
console.log("xixi");
}
var res=function(){
console.log("gunba");
}
66.字符串
let str = "hello,world";
//字符方法
str.charAt(1);//e
str.charCodeAt(1);//e的字符编码101
//字符串操作方法
str.concat(",xixi");//在字符串后面添加字符串
str.slice(-3);//rld 两个参数start end
str.substring(-3);//hello,world 两个参数start end
str.substr(-3);//rld start length
str.slice(3, -4);//"lo w"
str.substring(3, -4);//hel -4为0
str.substr(3, -4);//""
//大小写转换 建议使用第一种
str = "heLLo world"
//大写
str.toLocaleUpperCase();
str.toUpperCase();
//小写
str.toLocaleLowerCase();
str.toLowerCase();
//match方法
str = "中国移动10086，中国联通10010，中国电信10000";
let arr = str.match(/\d{5}/)
console.log(arr);
//search
str.search(/\d{5}/);//4 返回第一个所匹配到的索引
67.数据属性
//[[Configurable]]:表示能否通过delete删除属性而重新定义属性，是否修改属性的特性，或者
//能否把属性改为访问器属性，默认值为true
//[[Enumerable]]:表示是否能通过for-in循环返回属性，默认值为true
//[[Writable]]:表示能否修改属性的值，默认值为true
//[[Value]]:包含这个属性的数据值。读取属性值的时候，从这个位置读；写入属性值的时候，把
//新值保存在这个位置。默认值为undefined
var person={};
Object.defineProperty(person,"name",{
writable:false,
value:"yang"
});
console.log(person.name);
person.name="ting";
console.log(person.name);
68.constructor
//构造函数创建对象
//用构造函数方式创建函数，会导致不同的作用域链和标识符解析，但创建Function
//新实例的机制仍然是相同的，因此，不同实例上的同名函数是不相等的
function Otherset(){
return this.name;
}
function Person(name,age){
this.name=name;
this.age=age;
this.setName=function(){
return this.name;
}
this.Otherset=Otherset;
}
let per1=new Person("yang",18);
let per2=new Person("ting",20);
console.log(per1.setName==per2.setName,per1.Otherset==per2.Otherset); //false true
69.delete全局变量
var age=22;
window.color="red";
delete window.age; //false
delete window.color;//true
console.log(window.age,window.color);//22 undefind
70.窗口大小
window.innerWidth
document.documentElement.clientWidth
document.body.clientWidth
71.Math对象
Math.pow(2, 3); //=>8 2的3次幂
Math.round(2.5);//=>3 四舍五入
Math.ceil(.4);//=>1 向上求整
Math.floor(.6);//=>0向下求整
Math.abs(-5);//=>5 绝对值
// Math.max(x,y,z);//返回最大值
// Math.min(x,y,z);//返回最小值
Math.random();// >0and<1的随机数
Math.PI;//π
Math.E;//e 自然对数的底数
Math.sqrt(3);//3的平方根
Math.pow(3, 1 / 3);
Math.sin(30);//三角函数 ：Math.cos
Math.log(10);//10的自然对数
72.Date
let now=new Date()
now.getFullYear();
now.getMonth();
now.getDate();
now.getHours();
now.getMinutes();
now.getSeconds();
now.getDay();//星期
73.字符串
var str = "hello,world";
str.charAt(0);//第一个字符
str.charCodeAt(1);//101 e的字符编码
let s = str.substring(1, 4); //第2-4个字符
console.log(s);
str.substr(3);//lo,world
str.substr(-3);//rld;
str.slice(1, 4);//第2-4个字符
str.slice(-3);//最后三个字符
str.indexOf("l");//第一个出现的位置
str.lastIndexOf("l");//最后一次出现的字符
str.indexOf("1", 3);//在位置3及之后出现字符l的位置
str.split("");//切割成子串
// console.log( str.split("o"));
str.replace("l", "H");//替换第一个
// console.log( str.replace("o","H"));
str.toUpperCase();//大大大写
74.splice
arr.splice(1, 0, 3, 3, 2, 11);
//从索引1开始插入元素，删除0个，插入3,3,2,11
// arr.splice(1, 3)//删除元素，从索引1开始，删除3个
位运算
浙公网安备 33010602011771号