js

基本数据类型

string

转意符

方法

slice

let a='wo shi nide bb,wo ai ni'
console.log(a.slice(3,7));//从第几个开始到第几个结束，不包含最后一个
console.log(a);//slice不改变原理的string

substring

不同之处在于，小于 0 的 start 和 end 值在 substring() 中被视为 0。

substr

已经被弃用，谨慎使用

replace

let a='wo shi nide bb,wo ai ni'
console.log(a.replace('shi','bushi'));//把第一个替换成第2个，但是只替换第一个查找到的，全部替换需要用到正则
console.log(a);//不改变原理的string

let a='wo'
console.log(a.replace(a[0],'bushi'));//和索引联动
console.log(a);//不改变原理的string

let a='wo shi ni de haha'
console.log(a.replace(a.slice(0,5),'bushi'));//和slice联动
console.log(a);//不改变原理的string

toUpperCase

全大写呗

toLowCase

全小写呗

concat

let a='wo'
console.log(a.concat('shi','bushi'));//好像可以随便链接多少个
console.log(a);//不改变原理的string

不过如果我想把它前面添加东西岂不是不行？所以还是没有加法好啊

trim

这个就是清空string两边的空白

padStart

这是一个填充方法

let text = "556";
let padded = text.padStart(4,"x");//长度4，不够的用X填充
console.log(padded);
console.log(text);

padEnd

在尾部填充

charAt

var str = "HELLO WORLD";
str.charAt(0);            // returns H
var str = "HELLO WORLD";
str[0];                   // returns H

有人会问，这2个有啥区别，str[0]只能查询，不能改变

charCodeAt

这是返回的ACLL码

split

拆分字符串变成arrya

let a='today is very nice'
let b=a.split(' ')//以空格拆分
let c=a.split('')//这种其实表示把所有的字符都单独拆分
console.log(b);
console.log(c);
console.log(a);//并不会改变a本身

结果

[ 'today', 'is', 'very', 'nice' ]
[
  't', 'o', 'd', 'a', 'y',
  ' ', 'i', 's', ' ', 'v',
  'e', 'r', 'y', ' ', 'n',
  'i', 'c', 'e'
]
today is very nice

repeat

let string = 'love'
console.log(string.repeat(10)) // lovelovelovelovelovelovelovelovelovelove

search

indexOf()

let a='today is very nice today is hot'
console.log(a.indexOf('nice'));//只是输出第一个查到的index,如果没有返回-1

值得考虑的是，我们如何得到所有搜索的index

let a='today is very nice today is hot'
let arr=[]
let num=0
let atm=a.indexOf('o')
while(atm!=-1){
    arr.push(atm)
    num=atm
    a=a.slice(num)
    atm=a.indexOf('o',num)
}
console.log(arr);

从某个位置开始

let a='today is very nice today is hot'
console.log(a.indexOf('nice'，10));//只是输出第一个查到的index,如果没有返回-1

第2个参数表示从哪个位置开始

lastIndexOf()

从尾部开始第一个

search

let str = "Please locate where 'locate' occurs!";
str.search("locate");

和indexof一样的
不同点：
1.serch不能指定从某个 位置开始
2.serch可以用正则表达式来搜索

match

match() 方法在字符串中搜索与正则表达式的匹配项，并将匹配项作为 Array 对象返回。
所以，如果我们想知道一个字符串里面有多少个搜查项，用这个挺不错

let text = "The rain in SPAIN stays mainly in the plain";
console.log(text.match(/ain/g));
[ 'ain', 'ain', 'ain' ]

如果没有普匹配想，那么返回null

includes

这个简单就是判断是否包含某个字段，返回boolen

let text = "Hello world, welcome to the universe.";
text.includes("world");
true
let text = "Hello world, welcome to the universe.";
text.includes("world", 12);//第2个参数是开始的位置

startwith

let text = "Hello world, welcome to the universe.";
text.startsWith("world", 6)    // Returns true

endswith

let text = "Hello world, welcome to the universe.";
text.endsWith("world", 11);//前11个开始搜索

模板文字/格式化字符串

let r=0
let g=200
let bb=100
let eve=`color:rgb(${r},${g},${bb});`

number

值的范围

运算

取整的方法

let a=6.5
console.log(Math.trunc(a));//直接去除小数部分6
console.log(Math.round(a));//四舍五入7
console.log(Math.ceil(a));//向上取整7

与string的运算

let x = 5 + 5;
let y = "5" + 5;   
let z = "Hello" + 5;

结果

10
55       
Hello5

num+str =string
如果一个是str一个是num，那么 减法，乘法，除法最后的结果都是num

NaN

NaN 是 JavaScript 保留字，表示数字不是合法数字。 尝试使用非数字字符串进行算术运算将导致 NaN（非数字）：

NaN is a number: typeof NaN returns number:

infinitty

Infinity（或 -Infinity）是 JavaScript 将返回的值，如果您计算一个超出最大可能数字的数字。
除以 0（零）也产生 Infinity：

let x =  2 / 0;
let y = -2 / 0;

16进制

如果数字常量前面有 0x，JavaScript 会将其解释为十六进制。

let x = 0xFF;

默认情况下，JavaScript 将数字显示为以 10 为底的小数。 但是您可以使用 toString() 方法输出从 2 到 36 的数字。 十六进制是以 16 为底。十进制是以 10 为底。八进制是以 8 为底。二进制是以 2 为底。

let myNumber = 32;
myNumber.toString(32);
myNumber.toString(16);
myNumber.toString(12);
myNumber.toString(10);
myNumber.toString(8);
myNumber.toString(2);

method

tostring

let x = 123;
x.toString();
(123).toString();
(100 + 23).toString();

就是转换成str

toexponential

toExponential() 返回一个字符串，带有一个四舍五入的数字并使用指数表示法写入。 一个参数定义小数点后面的字符数：

let x = 9.656;
x.toExponential(2);//9.66e+0
x.toExponential(4);
x.toExponential(6);

我感觉用到的地方不是很多吧，

tofixed

let x = 9.656;
let b=x.toFixed(2)
console.log(b);//9.66
console.log(typeof(b));//sting

也是4舍5入

toprecision

let x = 9.6567856;
let b=x.toPrecision(4)//整数加小数一共4位，有四舍五入

valueof

在 JavaScript 中，数字可以是原始值（typeof = number）或对象（typeof = object）。 valueOf() 方法在 JavaScript 内部用于将 Number 对象转换为原始值。 没有理由在您的代码中使用它。3
All JavaScript data types have a valueOf() and a toString() method.

Number.isInterger

let a=10
console.log(Number.isInteger(a));//true
Number.isInteger(10.5);      // returns false

Number.isSafeInteger()

安全整数是可以精确表示为双精度数的整数。 如果参数是安全整数，则 Number.isSafeInteger() 方法返回 true。

Number.isSafeInteger(10);    // returns true
Number.isSafeInteger(12345678901234567890);  // returns false

Safe integers are all integers from -(253 - 1) to +(253 - 1).
This is safe: 9007199254740991. This is not safe: 9007199254740992.

全局方法

number

返回一个从其参数转换而来的数字。

Number(true);
Number(false);
Number("10");
Number("  10");
Number("10  ");
Number(" 10  ");
Number("10.33");
Number("10,33");
Number("10 33");
Number("John");
1
0
10
10
10
10
10.33
NaN
NaN
NaN

parseFloat

解析其参数并返回一个浮点数

parseFloat("10");
parseFloat("10.33");
parseFloat("10 20 30");
parseFloat("10 years");
parseFloat("years 10");
10
10.33
10
10
NaN

parseInt

解析其参数并返回一个整数

parseInt("-10");
parseInt("-10.33");
parseInt("10");
parseInt("10.33");
parseInt("10 20 30");
parseInt("10 years");
parseInt("years 10");
-10
-10
10
10
10
10
NaN

属性

max_value

min_value

positive_infinity

negative_infinity

NaN

NaN 是 JavaScript 保留字，表示数字不是合法数字。 尝试使用非数字字符串进行算术运算将导致 NaN（非数字）：
数字属性不能用于变量

object

getters setters

var person = {
  firstName: "John",
  lastName : "Doe",
  language : "NO",
  get lang() {
    return this.language;
  },
  set lang(value) {
    this.language = value;
  }
};
// Set an object property using a setter:
person.lang = "en";
// Display data from the object using a getter:
document.getElementById("demo").innerHTML = person.lang;

defineProperty()

它允许您定义对象属性和/或更改属性的值和/或元数据。

// Create an Object:
var person = {
  firstName: "John",
  lastName : "Doe",
  language : "NO",
};
// Change a Property:
Object.defineProperty(person, "language", {
  value: "EN",
  writable : true,
  enumerable : true,  //如果改false就不会读取出来了
  configurable : true
});
// Enumerate Properties
var txt = "";
for (var x in person) {
  txt += person[x] + "<br>";
}
document.getElementById("demo").innerHTML = txt;

/// Create an Object:
var person = {
  firstName: "John",
  lastName : "Doe",
  language : "NO"
};
// Change a Property:
Object.defineProperty(person, "language", {
  get : function() { return language },         
  set : function(value) { language = value.toUpperCase()}  //竟然可以直接设置它的变量更改的化都是大写
});
// Change Language
person.language = "en";
// Display Language
document.getElementById("demo").innerHTML = person.language;

object.entires

const person = {
    firstName: "John",
    lastName: "Doe",
    age: 50,
    eyeColor: "blue"
};
let a=Object.entries(person)
console.log(a)
//return  返回的是一个数组
[
  [ 'firstName', 'John' ],
  [ 'lastName', 'Doe' ],
  [ 'age', 50 ],
  [ 'eyeColor', 'blue' ]
]

Object.entries() makes it simple to use objects in loops:

const fruits = {Bananas:300, Oranges:200, Apples:500};
let text = "";
for (let [fruit, value] of Object.entries(fruits)) {
text += fruit + ": " + value + "
";
}

Object.entries() also makes it simple to convert objects to maps:

const fruits = {Bananas:300, Oranges:200, Apples:500};
const myMap = new Map(Object.entries(fruits));

object.values

Object.values 类似于 Object.entries，但返回对象值的单维数组：

const person = {
  firstName : "John",
  lastName : "Doe",
  age : 50,
  eyeColor : "blue"
};
document.getElementById("demo").innerHTML = Object.values(person);
[ 'John', 'Doe', 50, 'blue' ]

Object Rest Properties

let { x, y, ...z } = { x: 1, y: 2, a: 3, b: 4 };
x; // 1
y; // 2
z; // { a: 3, b: 4 }

symbol

JavaScript 符号是一种原始数据类型，就像数字、字符串或布尔值一样。 它代表一个唯一的“隐藏”标识符，没有其他代码可以意外访问。 例如，如果不同的编码人员想要将 person.id 属性添加到属于第三方代码的 person 对象，他们可以混合彼此的值。 使用 Symbol() 创建唯一标识符，解决了这个问题：

const person = {
  firstName: "John",
  lastName: "Doe",
  age: 50,
  eyeColor: "blue"
};
let id = Symbol('id');
person[id] = 140353;
// Now person[id] = 140353
// but person.id is still undefined

null

undefined

bigint

function

函数的访问

function run(x){
    return x+2
}
console.log(run); //这个访问的是函数对象
console.log(run(4));//这个访问的是函数结果

默认参数值

function myFunction(x, y = 10) {
  // y is 10 if not passed or undefined
  return x + y;
}
myFunction(5); // will return 15

剩余参数

function sum(...args) {
  let sum = 0;
  for (let arg of args) sum += arg;
  return sum;
}
let x = sum(4, 9, 16, 25, 29, 100, 66, 77);

Async

event

arrays

let x=[run(),'x',run]    //arrya里面是可以是object的本身或者运行的结果都是可以的
function run(){
    console.log('i am run 1');
}

创建可以用new来创建，但是new创建的时候可以有一个特殊的作用

const a=new Array(5)
console.log(a);
[ <5 empty items> ]   //等于说里面只有一个数字的时候就是创建了相对应数字的空集合

属性

length

sort

判断是否为数组

Arrya.isArrya(a)

const a=[1,2,3]
console.log(Array.isArray(a));
true

a instanceof Array

const a=[1,2,3]
let b=a instanceof Array
console.log(b);
true

方法

toString()

const a=[1,2,3]
console.log(a.toString());.
1,2,3

join()

const a=[1,2,3]
console.log(a.join("|"));
1|2|3

pop

const a=[1,2,3]
console.log(a.pop());
console.log(a);
3
[ 1, 2 ]

push

const a=[1,2,3]
let b=a.push(4)//返回的是新数组的长度
console.log(b);
console.log(a);
4
[ 1, 2, 3, 4 ]

shift

const a=[0,1,2,3]
let b=a.shift()//被移除的第一个是啥
console.log(b);
console.log(a);
0
[ 1, 2, 3 ]

unshift

添加呗 除了a.unshif()返回的是新的数组的长度

delete

const a=[0,1,2,3]
delete a[2]
console.log(a);
[ 0, 1, <1 empty item>, 3 ]   //删除的地方就是空位

concat

const a=[0,1,2,3]
const b=[4,5,6]
const c=a.concat(b)   //注意不能用加号，不然就会自动转换成string了
console.log(c);
[
  0, 1, 2, 3, 4, 5, 6
]

const arr1 = ["Cecilie", "Lone"];
const arr2 = ["Emil", "Tobias", "Linus"];
const arr3 = ["Robin", "Morgan"];
const myChildren = arr1.concat(arr2, arr3);

splice

const a=[0,1,2,3]
a.splice(1,1,88,99)
console.log(a);
[ 0, 88, 99, 2, 3 ]

这是一个在指定的位置添加新的元素的方法，
参数1：从哪个位置开始添加
参数2：要移除几个原来的元素
参数3-n：是要添加的元素
如果没有第3个参数就是移除指定位置的几个元素

slice

和string的一样用

sort

sort()

let a=[2,36,9,0,76,90]
a.sort()
console.log(a);

这里的排序都是按首字母来排的，挺2，没啥大用

sort(function(a, b){return a - b})

let a=[2,36,9,0,76,90]
a.sort((a,b)=>{return a-b})
console.log(a);
[ 0, 2, 9, 36, 76, 90 ]

let a=[2,36,9,0,76,90]
a.sort((a,b)=>{return b-a})
console.log(a);
[ 90, 76, 36, 9, 2, 0 ]

reverse

indexof lastindeof

和string一样用

迭代

foreach

let a=[2,36,9,0,76,90]
a.forEach((x,i)=>{
    console.log(`${i+1}----${x}`);
})
1----2
2----36
3----9
4----0
5----76
6----90

function myFunction(value, index, array) {
  txt += value + "<br>";
}

map

let a=[2,36,9,0,76,90]
let b=a.map((x)=>{
  return x*2  
})
console.log(b);
[ 4, 72, 18, 0, 152, 180 ]

map除了可以和forEach相同的用法外，它还可以return然后生成一个新的arrya

filter

let a=[2,36,9,0,76,90]
let b=a.filter((x)=>{
  return x>2  
})
console.log(b);
[ 36, 9, 76, 90 ]

它返回一个满足条件的数组

reduce

let a=[1,2,3,4,5,6,7,8,9,10]
let b=a.reduce((tot,i)=>{
    return tot+i
})
console.log(b);

reduce的返回函数有4个参数，不同的是第一个参数是total,total的意思是，每一次循环total的值，total的首个值肯定是arrya[0]。所以上面的意思就是1-10的累加。

let a=[1,2,3,4,5,6,7,8,9,10]
let b=a.filter((x)=>{   //先筛选出偶数
    return x%2==0
}).reduce((tot,i)=>{    //再来计算偶数的累乘
    return tot*i
})
console.log(b);

reduceRight()

从右向左运算···

every

const a=[0,1,2,3,20,10,11,4,99,5]
let b=a.every((x)=>{
    return x>5      //检测所有的元素是否符合，只要不符合就是false
})
console.log(b);  //false

some

const a=[0,1,2,3,20,10,11,4,99,5]
let b=a.some((x)=>{
    return x>5   //只要有符合的就返回true
})
console.log(b);   //true

find

const a=[0,1,2,3,20,10,11,4,99,5]
let b=a.find((x)=>{
    return x>5     //返回第一个满足条件的元素
})
console.log(b);   //20

findindex

const a=[0,1,2,3,20,10,11,4,99,5]
let b=a.findIndex((x)=>{
    return x>5    //返回第一个满足条件的index
})
console.log(b);   //4

array.from

let a='sdsalsad'
let b=Array.from(a)   //不就是把字符串分解嘛
console.log(b);  
[
  's', 'd', 's',
  'a', 'l', 's',
  'a', 'd'
]

array.keys

Array.keys() 方法返回一个带有数组键的 Array Iterator 对象。

const fruits = ["Banana", "Orange", "Apple", "Mango"];
const keys = fruits.keys();
for (let x of keys) {
  text += x + "<br>";
}

array.entries

生成一个key/value的迭代器

const fruits = ["Banana", "Orange", "Apple", "Mango"];
const f = fruits.entries();
for (let x of f){
    console.log(x);
}
[ 0, 'Banana' ]
[ 1, 'Orange' ]
[ 2, 'Apple' ]
[ 3, 'Mango' ]

Array includes()

const fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.includes("Mango"); // is true

Array.includes() 允许检查 NaN 值。与 Array.indexOf() 不同。

date

new Date()

new Date()
new Date(year, month, day, hours, minutes, seconds, milliseconds)
new Date(milliseconds)
new Date(date string)

注意：JavaScript 从 0 到 11 计算月份： 一月 = 0。 十二月 = 11。
指定高于 11 的月份，不会导致错误，但会将溢出添加到下一年：

formats

getdate

let a=Date.now()//现在时间的长计数形式
console.log(a);
1652190464811

setdate

const d = new Date();
d.setFullYear(2020);
const d = new Date();
d.setFullYear(2020, 11, 3);
const d = new Date();
d.setMonth(11);   //0-11
const d = new Date();
d.setHours(22);   //0-23

const d = new Date();
d.setTime(1829919)
console.log(d);

这个可以把数字转换成时间

math

属性

Math.E        // returns Euler's number
Math.PI       // returns PI
Math.SQRT2    // returns the square root of 2
Math.SQRT1_2  // returns the square root of 1/2
Math.LN2      // returns the natural logarithm of 2
Math.LN10     // returns the natural logarithm of 10
Math.LOG2E    // returns base 2 logarithm of E
Math.LOG10E   // returns base 10 logarithm of E

Math.round()

let a=Math.round(4.6)
let b=Math.round(4.5)
let c=Math.round(4.4)
console.log(a);
console.log(b);
console.log(c);

注意是四舍5入到整数

Math.ceil()

向上取整

Math.ceil(4.9);//5
Math.ceil(4.7);//5
Math.ceil(4.4);//5
Math.ceil(4.2);//5
Math.ceil(-4.2);//-4

Math.floor()

向下取证

Math.floor(4.9);//4
Math.floor(4.7);//4
Math.floor(4.4);//4
Math.floor(4.2);//4
Math.floor(-4.2);//-5

Math.trunc()

只保留整数部分

Math.trunc(4.9);//4
Math.trunc(4.7);//4
Math.trunc(4.4);//4
Math.trunc(4.2);//4
Math.trunc(-4.2);//-4

Math.sign()

返回正负0

Math.sign(-4);//-1
Math.sign(0);//0
Math.sign(4);//1

Math.pow()

次方计算82

Math.pow(8, 2);

Math.sqrt()

数学sqrt（x）返回x的平方根：

Math.sqrt(64);//8

Math.abs()

数学abs（x）返回x的绝对（正）值：

Math.abs(-4.7);//4.7

Math.sin()

数学sin（x）返回角度x（以弧度为单位）的正弦（介于-1和1之间的值）。 如果要使用度而不是弧度，则必须将度转换为弧度： 以弧度为单位的角度=以度为单位的角度xπ/180。

Math.sin(90 * Math.PI / 180);     // returns 1 (the sine of 90 degrees)

Math.cos()

数学cos（x）返回角x（以弧度为单位）的余弦（介于-1和1之间的值）。 如果要使用度而不是弧度，则必须将度转换为弧度： 以弧度为单位的角度=以度为单位的角度xπ/180。

Math.cos(0 * Math.PI / 180);     // returns 1 (the cos of 0 degrees)

Math.min() and Math.max()

数学敏（）和数学。max（）可用于在参数列表中查找最低或最高值：

Math.min(0, 150, 30, 20, -8, -200);
Math.max(0, 150, 30, 20, -8, -200);

Math.random()

数学random（）返回一个介于0（包括）和1（不包括）之间的随机数：

Math.random();

Math.log()

数学log（x）返回x的自然对数。 自然对数返回达到一定增长水平所需的时间：

Math.log(1);//0

Math.log2()

x的以2为底的对数。

Math.log2(8);//3

Math.log10()

以x的10为底的对数。

Math.log10(1000);//3

random

Math.floor(Math.random() * 10);

Math.floor(Math.random() * 11);

Math.floor(Math.random() * 100);

Math.floor(Math.random() * 10) + 1;

function getRndInteger(min, max) {     //不包含头，尾
  return Math.floor(Math.random() * (max - min) ) + min;
}
function getRndInteger(min, max) {     //包含头尾
  return Math.floor(Math.random() * (max - min + 1) ) + min;
}

if else

if (condition1) {
  //  block of code to be executed if condition1 is true
} else if (condition2) {
  //  block of code to be executed if the condition1 is false and condition2 is true
} else {
  //  block of code to be executed if the condition1 is false and condition2 is false
}

循环

switch

switch(expression) {
  case x:
    // code block
    break;
  case y:
    // code block
    break;
  default:
    // code block
}

switch (new Date().getDay()) {
  case 4:
  case 5:
    text = "Soon it is Weekend";
    break;
  case 0:
  case 6:
    text = "It is Weekend";
    break;
  default:
    text = "Looking forward to the Weekend";
}

for

for (let i = 0, len = cars.length, text = ""; i < len; i++) {
  text += cars[i] + "<br>";
}

可以看到如果声明变量的时候 ，如果语句过多，是可以用逗号隔开的

let i = 2;
let len = cars.length;
let text = "";
for (; i < len; i++) {
  text += cars[i] + "<br>";
}

let a=0
for(;a<10;){
    console.log(a);
    a++
}

这个例子可以看到即使3个条件都不写，也是可以工作的，但是你要在外部和内部加上条件，其实道理是一样的

for in

let a={name:'xiaoyu',age:56}
let b=[5,6,7,8,4,3,4]
for(i in a){
    console.log(i);
}
for (i in b){
    console.log(i);
}

主要是给object 和arrya用的，在object中是key,在arrya中是索引值
看下输出结果就知道了

name
age
0
1
2
3
4
5
6

for of

const cars = ["BMW", "Volvo", "Mini"];
let text = "";
for (let x of cars) {  //x地表数组里的每一个元素
  text += x;
}
console.log(text);

const cars = "JavaScript"
for (let x of cars) {
  console.log(x);  //x带表每一个字符
}

while

while (i < 10) {
  text += "The number is " + i;
  i++;
}

do {
  text += "The number is " + i;
  i++;
}
while (i < 10);

break

一般的break只是跳出当前的循环层
这里我们看下label的运用

var num=0;
outter:                         //label语句，名字可自定义
for(var i=0;i<10;i++){
    for(var j=0;j<10;j++){
        if(i==5&&j==5){
            break ;             //跳出当前循环，但会继续执行外循环
        }
        num++;
    }
}
document.write(num);   //95
————————————————
var num=0;
outter:
for(var i=0;i<10;i++){
    for(var j=0;j<10;j++){
        if(i==5&&j==5){
            break outter;    //退出内部循环，指向outter，即外循环，同时退出外循环
        }
        num++;
    }
}
document.write(num);   //55

set

它是一个集合，但是它里面的值只能唯一，不能重复
set集合里面不存在索引，里面没有什么顺序的问题

const a=['a','a',9,8,7]
const b=new Set(a)
console.log(b);

它的输出结果为

Set(4) { 'a', 9, 8, 7 }

可以看到a只有一个了，注意它的结果是一个大括号，和arrya不同

增删改查

let a=[9,9,2,4,5,5,4]
const b=new Set(a)
b.add(10) //增
b.delete(9)//删
console.log(b.has(12));//查，如果有就ture

没错，set里面的值真的是不能够改掉，这可能是set做的安全性的问题。

size

console.log(b.size);//就是里面有几个值

values

map

let a=new Map()
a.set(1,'xiao')
a.set('xiao',12)
console.log(a);

输出的结果

Map(2) { 1 => 'xiao', 'xiao' => 12 }

map就是一个键值对，但是和object不同的是，这里的key可类型的。和set一样，里面的key是唯一的

增删改查

let a=new Map()
a.set('age',16)//增
a.set('name','xiaoyu')
a.delete('age')//删
a.set('name','gaga')//改
a.get('name')//可以查这个key的值
console.log(a.has('name'));//查

size

console.log(b.size);//就是里面有几个值

forEach

a.forEach((a,b)=>{
    console.log(`${a}--${b}`);
})//参数1表示值，b表示key

entries()

Returns an iterator with the [key, value] pairs in a Map

typeof

typeof "John"                 // Returns "string"
typeof 3.14                   // Returns "number"
typeof NaN                    // Returns "number"
typeof false                  // Returns "boolean"
typeof [1,2,3,4]              // Returns "object"
typeof {name:'John', age:34}  // Returns "object"
typeof new Date()             // Returns "object"
typeof function () {}         // Returns "function"
typeof myCar                  // Returns "undefined" *
typeof null                   // Returns "object"

类型转换

string转num

Number("3.14")    // returns 3.14
Number(" ")       // returns 0
Number("")        // returns 0
Number("99 88")   // returns NaN

可以看到如果不符合num的格式，那么就会出现NaN

num转string

let a=23
let b=String(a)//方式1
let c=a.toString()//方式2
console.log(typeof(b));
console.log(typeof(c));

date转num,string

d = new Date();
Number(d)          // returns 1404568027739
d = new Date();
d.getTime()        // returns 1404568027739

String(Date())  // returns "Thu Jul 17 2014 15:38:19 GMT+0200 (W. Europe Daylight Time)"
Date().toString()  // returns "Thu Jul 17 2014 15:38:19 GMT+0200 (W. Europe Daylight Time)"

boolean转num,string

Number(false)     // returns 0
Number(true)      // returns 1

false.toString()   // returns "false"
true.toString()    // returns "true"

自动类型转换

5 + null    // returns 5         because null is converted to 0
"5" + null  // returns "5null"   because null is converted to "null"
"5" + 2     // returns "52"      because 2 is converted to "2"
"5" - 2     // returns 3         because "5" is converted to 5
"5" * "2"   // returns 10        because "5" and "2" are converted to 5 and 2

按位运行

？

正则表达式

基本格式

/pattern/modifiers;

测试

const pattern = /e/;
pattern.test("The best things in life are free!");//返回Boolean

exec

let b=/e/.exec("The best things in life are free!");
console.log(b);

会返回一个对象，
[
‘e’,
index: 2,
input: ‘The best things in life are free!’,
groups: undefined
]

Errors

Throw, and Try…Catch…Finally

<p id="demo"></p>
<script>
try {
  adddlert("Welcome guest!");
}
catch(err) {
  document.getElementById("demo").innerHTML = err.message;
}
</script>

try {
  Block of code to try
}
catch(err) {
  Block of code to handle errors
}
finally {
  Block of code to be executed regardless of the try / catch result
}

throw

<!DOCTYPE html>
<html>
<body>
<p>Please input a number between 5 and 10:</p>
<input id="demo" type="text">
<button type="button" onclick="myFunction()">Test Input</button>
<p id="p01"></p>
<script>
function myFunction() {
  const message = document.getElementById("p01");
  message.innerHTML = "";
  let x = document.getElementById("demo").value;
  try {
    if(x == "") throw "empty";        //throw的内容就是err
    if(isNaN(x)) throw "not a number";
    x = Number(x);
    if(x < 5) throw "too low";
    if(x > 10) throw "too high";
  }
  catch(err) {
    message.innerHTML = "Input is " + err;
  }
}
</script>
</body>
</html>

strict

“严格使用”；定义JavaScript代码应在“严格模式”下执行。
“use strict”指令是ECMAScript版本5中的新指令。 它不是一个语句，而是一个文字表达式，被早期版本的JavaScript忽略。 “使用严格”的目的是指示代码应在“严格模式”下执行。 例如，在严格模式下，不能使用未声明的变量。 除Internet Explorer 9及更低版本外，所有现代浏览器都支持“严格使用”：

声明严格模式 严格模式通过添加“使用严格”来声明；到脚本或函数的开头。 在脚本开头声明，它具有全局作用域（脚本中的所有代码都将以严格模式执行）：

"use strict";
x = 3.14;       // This will cause an error because x is not declared
"use strict";
myFunction();
function myFunction() {
  y = 3.14;   // This will also cause an error because y is not declared
}

类class

class Car{
    constructor(a,b){  //构造函数
        this.a=a      //初始化数据
        this.b=b
        this.name='xiaoyu'  //也可以直接定义内部属性
    }
    run(){    //内部方法
        console.log(`${this.a}--${this.b}`);
    }
}
let a=new Car('aodi','bmw')
a.run()
console.log(a.name);