常用关键字

        YAML
        
      
var: 代码块内部声明，外部也可以使用;可以无限声明
let: 声明的变量只在let所在代码块有效；重复声明会报错(使用let会更严谨)
const: 声明常量

var与let的比较

        JAVASCRIPT
        
      
// 声明位置的区别
// 使用var
for (var a = 0; a < 10; a++) {

}
console.log(a); // 可以输出a

// 使用let
for (let b = 0; b < 10; b++) {

}
console.log(b); // 不可以输出b


// 声明个数的区别
var c = 1；
var c = 2；// 没有问题

let d = 1；
let d = 2；// 声明错误

常用函数

        YAML
        
      
Symbol: 用于创建唯一ID（表示键值对的键或枚举常量），可加参数（参数作为描述性字符）
Math: 可用于随机坐标
    random(): 随机取0-1的小数[0, 1)
    ceil(): 向上取整
    floor(): 向下取整
    round(): 四舍五入
    abs(): 取绝对值，可用于计算游戏间的距离
    pow(10, 2): 幂次计算，第一个参数是数值，第二个参数是幂次
    sqrt(): 用于开平方，可计算直角三角形的斜边
    asin(): 获取反正弦值
    PI: 获取圆周率。弧度一圈2PI

Symbol使用

        JAVASCRIPT
        
      
// 无论是否有参数，参数也无论是否相同，变量都是不同的，唯一的
let number = Symbol();
let number2 = Symbol('hello');
let number3 = Symbol('hello');
console.log(number2 == number3);// false

// 创建唯一常量，用于键的标识
const HEIGHT = Symbol();
const WEIGHT = Symbol();
// 使用对象的中括号方式赋值一个键值对
let test = {
    [HEIGHT]: 180
};
// 使用数组的中括号方式赋值一个键值对
test[WEIGHT] = 140;
// 读取数值
console.log(test[WEIGHT]);

// 使用Symbol和普通键生成的键值对信息
// Symbol的键值对可以看成面向对象的private，即私有化属性
let test = {
    [Symbol("name")]: "test",
    age: 18
};
console.log(Object.keys(test));// 只能打印出普通的键
console.log(Object.getOwnPropertySymbols(test));// 只能打印Symbol的键
console.log(Reflect.ownKeys(test));// 使用反射获取所有的键


// 创建枚举常量
const TYPE = 'AUDIO';// 使用这种，开发者可以用字符串来进行比对，不严禁（xxx == 'AUDIO'）
conse TYPE = Symbol();// 使用这种，开发者就只能用常量来比较了（xxx == TYPE）

Math使用

        JAVASCRIPT
        
      
// 计算两个人之间的角度，用于射击时使用
// 敌人坐标
let first = [100, 100];
// 自己坐标
let second = [200, 200];
// 计算两人间的x， y方向距离
let x = Math.abs(first[0] - second[0]);
let y = Math.abs(first[1] - second[1]);
// 获取斜边长度
let z = Math.sqrt(x * x + y * y);
// 获取角度，先计算正弦值，然后用反正弦获取弧度（一圈2PI），看有几分之半圈，然后*180获取角度，
let angle = Math.asin(y/z) / Math.PI * 180;
console.log(Math.round(angle));

解构赋值

可以更方便的赋值，常用于数组与对象
注意：数组是[]，对象是{}

        JAVASCRIPT
        
      
// 声明多个变量, 需要一一对应
let [a, b, c] = [1, 2, 3];
// 声明时嵌套数组
let [a, [b], c] = [1, [2], 3];
// 声明的时候跳过没有定义的变量，c直接是3
let [a, , c] = [1, [2], 3];
// 剩余运算符，a接收第一个数字，b接收后边所有的数字，成为了一个数组
let [a, ...b] = [1, 2, 3];
// 声明的时候直接赋值，后边没有赋值默认使用声明时候的值
let [a = 1, b = [5]] = [1, [2, 3]];// b是[2, 3]
let [a = 1, b = [5]] = [];// b是[5]。什么都不写默认是undefined，用的是最先声明时候的值
let [a] = [];// 声明时没有赋值，后边也没有赋值，a就是undefined
let [a, b, c, d, e] = "Hello";// 将字符串的每个字符赋值到前边的变量


// 对象的解构
let {first, second} = {first: 12, second: "test"}
// 嵌套的对象解构
let obj = {p: ["hello", {y: "world"}]};
let {p: [x, {y}]} = obj;// x为hello， y为world
let {p: [x, {}]} = obj;// x为hello， 另一个解构则忽略
// 不完全解构
let obj = {p: [{y: "world"}]};
let {p: [{y}, x]} = obj;// 解构一一对应，y为world，x为undefined
// 剩余运算符
let {a, b, ...rest} = {a: 1, b: 2, c: 3, d: 4};// a, b分别赋值，rest成为一个对象
// 解构默认值
let {a = 10, b = 5} = {a: 3};// a解构为3， b无法解构，默认为5
let {a: aa = 10, b: bb = 5} = {a: 3};// aa解构为3， bb无法解构，默认为5

函数写法

命名函数
JAVASCRIPT
1
2
3
function test() {

}

匿名函数(不需要写函数名，用变量接收)

        JAVASCRIPT
        
let test = function () {

}；
test();// 调用时用变量名()调用

自执行函数（自己调用自己，声明之后直接调用,只使用一次）

        JAVASCRIPT
        
      
// 第一种写法
// 用第一个括号包起来函数，第二个括号用来传参
(function(n1, n2) {
    console.log("" + n1 + n2);
})(1, 100);

// 第二种写法,最外边的括号直接将参数包裹
(function(n1, n2) {
    console.log("" + n1 + n2);
}(1, 100));

箭头函数

        JAVASCRIPT
        
      
// =>左边是参数，右边是函数体，然后用变量接收这个函数
let test = z => z + z;// 函数体少，就不需要加大括号了
console.log(test(10));// 执行的时候传参即可

// 多个参数的时候需要加小括号
let test = (a, b) => a + b;
console.log(test(10, 11));// 执行的时候传参即可

// 如果函数有多行代码，可以加大括号
let test = (a, b) => {
    let c = a + b;
    return c;
}
console.log(test(10, 11));// 执行的时候传参即可

箭头函数返回对象

        JAVASCRIPT
        
      
let test = (first, second) => {
    a: first,
    b: second
};// 这样写方法体，浏览器无法判断返回的是对象还是代码块
// 所以返回对象的时候要加一个括号
let test = (first, second) => ({
    a: first,
    b: second
});
let result = test(1, 2);// 将对象赋值给新变量
console.log(result.a);

箭头函数的this
普通函数的this，谁调用指向谁，没有调用者则指向window
箭头函数的this，指向函数定义时的对象
箭头函数的this，先从父级作用域找，父级作用域还是箭头函数，则继续向上找

        JAVASCRIPT
        
      
var name = "window";// 使用let定义，则无法被window对象读取，需要使用var
// 定义一个js对象
const test = {
    name: "test",
    nativeFunc: function() {
        console.log(this.name);
        return function() {
            // 这是返回的普通函数，被调用时没有指向对象，故使用window对象
            console.log("返回原生函数" + this.name);
        }
    },
    arrowFunc: function() {// 括号是参数，后边是返回值
        console.log(this.name);
        return () => {
            // 这是返回的箭头函数，调用时使用的定义时对象内的值
            console.log("返回箭头函数" + this.name);
        }
    }
}

let nativeFunc = test.nativeFunc();// 这里是test对象调用，使用test中的name，最后返回一个方法
let arrowFunc = test.arrowFunc();
nativeFunc();// 执行没有调用对象的普通方法
arrowFunc();// 执行没有调用对象的箭头方法

const test2 = {
    name: "lala"
};
nativeFunc.call(test2);// call传入数据后，原方法的this指向的变量使用传入数据的属性
arrowFunc.call(test2);// 箭头函数使用call后，数据还是使用原来定义时的数据

常用数据结构

Map
Map与Object（对象）的区别

Object的键只能是字符串或者Symbol，Map的键可以是任意值
Map的键值是先进先出，Object键值不固定
Map的键值个数可以用size属性获取，Object的键值数需要手动计算

同一个Map对象可以放不同类型的键

        JAVASCRIPT
        
      
let testMap = new Map();
// string作为键值
testMap.set("test", "test1");
console.log(testMap.get("test"));
console.log(testMap.size);

// 对象作为键值
let objTest = {};
testMap.set(objTest, "test2");
console.log(testMap.get(objTest));
console.log(testMap.size);

Set
可存储不同类型的值，但值唯一
Set的+0和-0是恒等的，不可重复存储
undefined与undefined恒等，不可重复存储
NaN和NaN不恒等，但也只能存一个

数组和Set的互相转化

        JAVASCRIPT
        
      
let testArray = ["test", "test"];// 数组数据可重复
console.log(testArray);
let testSet = new Set(testArray);// 将数组转为Set
console.log(testSet);
testArray =[...testSet];// Set转为数组
console.log(testArray);

Set作用

        JAVASCRIPT
        
      
// 数组去重
let testArray = ["test", "test"];
console.log([...testArray]);// 去重后将Set再转为Array

// Set并集，通过将多个Set转为数组，然后再转为Set
let testArray1 = ["test", "test2"];
let union = new Set([...testArray, ...testArray1]);
console.log(union);

// Set交集，先将一个集合变为数组，然后用filter函数查看该数组中的元素是否在另一个集合，在就留
let a = new Set(["test", "test"]);
let b = new Set(["test", "test2"]);
let intereset = new Set([...a].filter(x => b.has(x)));
console.log(intereset);

// Set差集，先将一个集合变为数组，然后用filter函数查看该数组中的元素是否在另一个集合，不在就留
let a = new Set(["test", "test"]);
let b = new Set(["test", "test2"]);
let difference = new Set([...b].filter(x => !a.has(x)));
console.log(difference);

面向对象的编程

        JAVASCRIPT
        
      
// 创建一个类
class Point {
    // 使用构造函数
    constructor(x, y) {
        this.x = x;
        this.y = y;
    }

    // 定义方法
    toString() {
        return "x = " + this.x + ", y = " + this.y;
    }
}
let point = new Point(100, 100);
console.log(point.toString());

// 通过函数嵌套来创建对象
function createPerson(name) {
    // 创建一个Object对象，给他赋值属性和方法，返回该对象
    let obj = new Object();
    
    obj.name = name;
    obj.showName = function() {
        return this.name;
    };

    return obj;
}
let p1 = createPerson("test");
console.log(p1.showName());

// 直接用函数来创建对象
function createPerson(name) {
    this.name = name;
    this.showName = function() {
        return this.name;
    };
}
let p1 = new createPerson("test");// 通过new创建对象
console.log(p1.showName());