对象·map·set·正则

对象访问属性：
    点符号: obj.name。
    方括号 obj["name"]，方括号允许从变量中获取键，例如 obj[varWithKey]。
删除对象的属性：delete obj.prop。
检查是否存在给定键的属性："key" in obj。
遍历对象：for(let key in obj) 循环。
检查空对象：isEmpty(obj) 函数，当对象没有属性的时候返回 true，否则返回 false

可选链 ?. 语法有三种形式：
obj?.prop —— 如果 obj 存在则返回 obj.prop，否则返回 undefined。
obj?.[prop] —— 如果 obj 存在则返回 obj[prop]，否则返回 undefined。
obj.method?.() —— 如果 obj.method 存在则调用 obj.method()，否则返回 undefined。

检查对象是否具有某个属性:
users.hasOwnProperty('Alan');  包含时返回true，否则返回false
'Alan' in users; 包含时返回true，否则返回false

获取到对象得属性名方法：
1.Object.keys(obj) 
使用 Object.keys() 生成对象所有键组成的数组
Object.keys() 方法会返回一个由一个给定对象的自身可枚举属性组成的数组，数组中属性名的排列顺序和正常循环遍历该对象时返回的顺序一致 

例如：
var anObj = { 100: 'a', 2: 'b', 7: 'c' };
console.log(Object.keys(anObj));   // console: ['2', '7', '100']

2.for...in
for (变量 in 对象)
{
    // 变量是属性名，在此执行代码
}
3.Object.getOwnPropertyNames(obj)
Object.getOwnPropertyNames()方法返回一个由指定对象的所有自身属性的属性名（包括不可枚举属性但不包括Symbol值作为名称的属性）组成的数组。
例如：
// 类数组对象
var obj = { 0: "a", 1: "b", 2: "c"};
console.log(Object.getOwnPropertyNames(obj).sort()); // ["0", "1", "2"]

// 使用Array.forEach输出属性名和属性值
Object.getOwnPropertyNames(obj).forEach(function(val, idx, array) {
  console.log(val + " -> " + obj[val]);
});

string.toLowerCase()  // 把字符串全部转成小写
string.split('');  // 把字符串转成数组格式，以单个字母分开
strArr.join('')   // 把数组转成字符串格式
strArr.reverse()   // 把数组反转

Map  和 Set

Map  是一个带键的数据项的集合，就像一个 Object 一样。 但是它们最大的差别是 Map 允许任何类型的键（key）。 
Set 是一个特殊的类型集合 —— “值的集合”（没有键），它的每一个值只能出现一次。

Map  基本属性
它的主要方法如下：

• let map = new Map() —— 创建 map。
• map.set(key, value) —— 根据键存储值。
• map.get(key) —— 根据键来返回值，如果 map 中不存在对应的 key，则返回 undefined。
• map.has(key) —— 如果 key 存在则返回 true，否则返回 false。
• map.delete(key) —— 删除指定键的值。
• map.clear() —— 清空 map。
• map.size —— 返回当前元素个数。

链式调用：map.set('1', 'str1').set(1, 'num1').set(true, 'bool1');
如果要在 map 中使用循环，可以使用以下三个方法：
    map.keys（）遍历并返回所有的键。
    map.value（）遍历并返回所有的值。
    map.entries（）遍历并返回所有实体

Set基本属性
它的主要方法如下：

• new Set(iterable) —— 创建一个 set，如果提供了一个 iterable 对象（通常是数组），将会从数组里面复制值到 set 中。
• set.add(value) —— 添加一个值，返回 set 本身
• set.delete(value) —— 删除值，如果 value 在这个方法调用的时候存在则返回 true ，否则返回 false。
• set.has(value) —— 如果 value 在 set 中，返回 true，否则返回 false。
• set.clear() —— 清空 set。
• set.size —— 返回元素个数。

正则：
1. 该.test()方法采用正则表达式，将其应用于字符串（放在括号内），然后返回true或false
let testStr = "freeCodeCamp";
let testRegex = /Code/;
testRegex.test(testStr);  // Returns true

2.不区分字母大小写 i标志
/ignorecase/i

2.全局搜索 g标志
/ignorecase/g
结合：/ignorecase/gi

4.该 .match()  返回字符串
let ourStr = "Regular expressions";
let ourRegex = /expressions/;
ourStr.match(ourRegex);  // Returns ["expressions"]

5.匹配文字模式（/literal/）是完全匹配 和通配符（/./）是匹配所有
放在方括号（[]）中来定义一组希望匹配的字符
let bigStr = "big";
let bagStr = "bag";
let bugStr = "bug";
let bogStr = "bog";
let bgRegex = /b[aiu]g/;
bigStr.match(bgRegex); // Returns ["big"]
bagStr.match(bgRegex); // Returns ["bag"]
bugStr.match(bgRegex); // Returns ["bug"]
bogStr.match(bgRegex); // Returns null

6.匹配小写字母a到e，你可以使用[a-e]。
let bgRegex = /[a-e]/;
在字符集中，你可以使用连字符（-）来定义要匹配的字符范围。

7. /[[a-z0-9]/匹配0和9之间的任意数字和a到z的字母，包含0和9和a和z。
let bgRegex = /[a-z0-9]/;

8.创建否定字符集
   在开始括号后面和不想匹配的字符前面放置插入字符（即^）
   /[^aeiou]/gi匹配所有非元音字符。注意，字符.、!、[、@、/和空白字符等也会被匹配，该否定字符集仅排除元音字符。

9.匹配出现一次或者连续多次的的字符（或字符组）
let bogStr = "abc";
let bogStr1 = "aabc";
let bgRegex = /a+/g；
let result = bogStr .match(bgRegex ); // ["a"]
let result = bogStr1 .match(bgRegex ); // ["aa"]

10.匹配出现零次或多次的字符
let soccerWord = "gooooooooal!";
let gPhrase = "gut feeling";
let goRegex = /go*/;
soccerWord.match(goRegex);  // Returns ["goooooooo"]
gPhrase.match(goRegex);  // Returns ["g"]
匹配"g"及其之后出现的零个或多个"o"

11.贪婪匹配，会匹配到符合正则表达式匹配模式的字符串的最长可能部分，并将其作为匹配项返回。
let text = "titanic";
let myRegex = /t[a-z]*i/；
let result = text.match(myRegex);  // ["titani"]
 懒惰匹配，它会匹配到满足正则表达式的字符串的最小可能部分。，并将其作为匹配项返回。
let text = "titanic";
let myRegex = /t[a-z]*?i/；
let result = text.match(myRegex);  // ["ti"]
是一个以t开始，以i结束，并且中间有一些字母的匹配模式。

12.字母z在一行中出现一次或连续多次时，正则表达式/z+/会匹配到它
let crowd = 'ABCzzzz';
let reCriminals = /z+/; // 修改这一行
let matchedCriminals = crowd.match(reCriminals);  // "zzzz"

13.使用^符号来搜寻字符串开头的匹配模式
let rickyAndCal = "Cal and Ricky both like racing.";
let calRegex = /^Cal/; // 修改这一行
let result = calRegex.test(rickyAndCal);

14.使用正则表达式的美元符号$来搜寻字符串的结尾。
let caboose = "The last car on a train is the caboose";
let lastRegex = /caboose$/; // 修改这一行
let result = lastRegex.test(caboose);

15.匹配字母和数字的所有符号。\w，这个缩写等同于[A-Za-z0-9_]。它不仅可以匹配大小写字母和数字，注意，它还会匹配下划线字符（_）
let longHand = /[A-Za-z0-9_]+/;
let numbers = "42";
longHand.test(numbers); // Returns true

16.匹配除了字母和数字的所有符号。\w相反的匹配模式。注意，相反匹配模式使用大写字母\W。此缩写与[^A-Za-z0-9_]是一样的
let shortHand = /\W/;
let numbers = "42%";
let sentence = "Coding!";
numbers.match(shortHand); // Returns ["%"]
sentence.match(shortHand); // Returns ["!"]

17.匹配所有数字，\d小写的d，这等同于字符类[0-9]
    匹配所有非数字，\D大写的D，这等同于字符类[^0-9]

18.\s匹配模式不仅匹配空格，还匹配回车符、制表符、换页符和换行符,与[\r\t\f\n\v]类似
\S匹配模式匹配非空白字符，也将不匹配空格、回车符、制表符、换页符和换行符，与[^\r\t\f\n\v]类似

19.+查找一个或多个字符，使用星号*查找零个或多个字符
数量说明符{n,m}指定匹配模式的上下限，其中n <= m。最少匹配 n 次且最多匹配 m 次
{n,}指定匹配模式的下限而不需要指定上限
{n}指定一定数量的匹配模式，只需在大括号之间放置一个数字

20.问号?检查前面的零个或一个元素,此符号视为前面的元素是可选的
let favWord = "favorite";
let favRegex = /favou?rite/; 
let result = favRegex.test(favWord);

21.正向先行断言会查看并确保搜索匹配模式中的元素存在，但实际上并不匹配。
正向先行断言的用法是(?=...)，其中...就是需要存在但不会被匹配的部分。

负向先行断言会查看并确保搜索匹配模式中的元素不存在。
负向先行断言的用法是(?!...)，其中...是你希望不存在的匹配模式。如果负向先行断言部分不存在，将返回匹配模式的其余部分。