function Dog(name) { //定义构造函数
   this.name = name; //构造函数本身的属性 --自有属性
   this.sayName = function (){
    　　console.log("name is " + this.name);
   }
}
//通过构造函数的显示原型prototype属性新增属性或方法
Dog.prototype.color = 'black';
let dog = new Dog('huahua');
console.log(dog);
console.log("原型color属性:", dog.color);  //black
console.log("自有name属性:",dog.name);  //huahua
Dog.prototype.name = '小丽';
console.log("使用原型对name属性赋值后的自有name属性:", dog.name);
console.log("对象可有自有name属性:", dog.hasOwnProperty("name")) //false name属性只存在于原型对象中
delete dog.name; //删除对象的自有属性,无法删除原型属性
console.log("删除自有name属性后可访问到原型name属性:",dog.name);
console.log("对象可有自有name属性:", dog.hasOwnProperty("name")) //false name属性只存在于原型对象中

var fnObj = new Function();
console.log(fnObj)
console.log(fnObj.prototype) //默认指向一个Object空实例对象，没有我们的属性
console.log(fnObj.prototype.constructor === fnObj) //true
function Foo(){} //相当于var Foo = new Function()，所以Foo是个对象,对象都有隐式原型__proto__
console.log(Foo) 
console.log("显式原型对象：",Foo.prototype) 
console.log("原型对象中都有一个constructor属性指向函数对象", Foo.prototype.constructor === Foo) //true
//为原型中添加test()方法
Foo.prototype.test = function(){
    console.log('这里是为原型中添加的方法')
}
var fObj = new Foo() //创建实例对象时，内部产生语句: this.__proto__ = F.prototype
console.log("实例化后：", fObj) 
fObj.test();
console.log("实例对象的隐式原型的值和其构造函数显式原型的值对应", fObj.__proto__ === Foo.prototype) // true

npm install --save-dev webpack
npm install --save-dev webpack-cli

"scripts": {
　　"start": "webpack --config webpack.config.js"
}

...
export default defineConfig({
  ...
  envDir: path.resolve(__dirname, './env')
})

legacy({
  renderLegacyChunks: false,
  modernPolyfills: ['es.global-this'],
})

npm i @vitejs/plugin-legacy  --save

import { defineConfig } from 'vite'
import vue from '@vitejs/plugin-vue'
import path from "path"
import legacy from "@vitejs/plugin-legacy"
export default defineConfig({
    plugins: [
        vue(),
        legacy({
            // polyfills: ["es.promise.finally", "es/map", "es/set"],
         //    targets: ["chrome 49"],
         //    // modernPolyfills: ["es.promise.finally"],
            additionalLegacyPolyfills: ['regenerator-runtime/runtime'],
            // modernPolyfills: true,
            targets: ['chrome 49', 'edge < 15'],
            renderLegacyChunks: true,
        }),
    ],
    //定义短路经别名
    resolve: {
        alias: {
          // 如果报错__dirname找不到，需要安装node,执行npm install @types/node --save-dev
          "@": path.resolve(__dirname, "src"),
          "@assets": path.resolve(__dirname, "src/assets"),
          "@components": path.resolve(__dirname, "src/components"),
          "@images": path.resolve(__dirname, "src/assets/images"),
          "@views": path.resolve(__dirname, "src/views"),
          "@store": path.resolve(__dirname, "src/stores"),
        },
    },
    //跨域处理，重写路径,替换/api
    server: { 
        proxy: {
            '/api': {
                target: 'http://localhost:3000', //目标url
                changeOrigin: true, //支持跨域
                rewrite: (path) => path.replace(/^\/api/, "http://testwechat.ispeak.cn/"), 
            }
        }
    },
    // ...esbuild({
    //   //替换成你想要的谷歌内核版本
    //   target: 'chrome64',
    //   loaders: {
    //     '.vue': 'js',
    //     '.ts': 'js'
    //   }
    // }),
})

getAssetsFile: (url) => {
    return new URL(`/src/assets/${url}`, import.meta.url).href
}

bgImg.src = this.utils.getAssetsFile('images/bg.jpg');

"use strict" 指令
String.trim()
Array.isArray()
Array.forEach()
Array.map()
Array.filter()
Array.reduce()
Array.reduceRight()
Array.every()
Array.some()
Array.indexOf()
Array.lastIndexOf()
JSON.parse()
JSON.stringify()
Date.now()
属性 Getter 和 Setter
新的对象属性和方法

var str = "    Hello World!    ";
console.log("|" + str.trim() + '|'); 

var arr = [65, 62, 63, 26, 61];
let res = arr.every(function(value) {
　　 console.log(value);
    return value > 60;
})
console.log(arr, res);

var arr = [65, 62, 80, 61];
let res = arr.some(function(value) {
    console.log(value);
    return value > 78;
})
console.log(arr, res);

var fruits = ["d", "a", "b", "a", "c"];
var index = fruits.indexOf("a");
console.log(index); // 返回1
index = fruits.indexOf("12");
console.log(index); //不存在，返回-1

var fruits = ["d", "a", "b", "a", "c"];
var index = fruits.lastIndexOf("a");
console.log(index); //3
index = fruits.lastIndexOf("12");
console.log(index); //-1

var obj = JSON.parse('{ "name":"小镭", "age":10000}');

var str = JSON.stringify({ "name":"小镭", "age":10000});
console.log(typeof  str, str);

var time = Date.now();
console.log(time);
time = Date(Date.now()); 
console.log(time);
time =new Date().getTime()
console.log(time);

const obj2 = {
    _nickname: 2,
    age: 10,
    get nickname() {
        console.log('自动执行Getter对象属性了');
        return this._nickname;
    },
    set nickname(val) {
        console.log('自动执行Setter对象属性了');
        this._nickname = val
    }
}
console.log(obj2);
const res2 = Object.getOwnPropertyDescriptor(obj2, 'nickname')
console.log('res2的nickname属性的属性描述符：', res2)
console.log('nickname属性的get名称：', res2.get.name) // get nickname
console.log('nickname属性的set名称：', res2.set.name) // set nickname
obj2.nickname = 'cdf'; // 为属性赋值时,set函数监控到数据变化会自动执行
console.log(obj2.nickname); // 读取属性时,get函数监控到数据变化会自动执行

var person = {
    name: "",
    get getName() {
        return this.name;
    },
    set setName(value) {
        this.name = value;
    }
};
// 使用setter设置对象属性，然后使用Getter获取对象属性
person.setName = "cdf";
console.log(person.getName); //输出cdf

var person = {name:'cdf', language : "NO"};
let desc = Object.getOwnPropertyDescriptor(person, 'language');
console.log(desc);
// 更改属性：
Object.defineProperty(person, "language", {
    value: "EN",
    writable : false,
    enumerable : true,
    configurable : true
});
console.log("更改language值为CN，并设置描述符不可写：",  person);
console.log("language可枚举：", Object.keys(person));
// person.language = 'CN'; //会报错，因为上一步在属性描述符中把它限制为不可重写
Object.defineProperty(person, "language", {
    value: "CN",
    writable : false,
    enumerable : false,
    configurable : false
});
console.log("language不可枚举后：", Object.keys(person));
console.log("更改language值为CN，并多设置描述符不可再被更改、不可配置：",  person);
// Object.defineProperty(person, "language", { //不可配置后，就不可修改enumerable和configurable为其它值了，如果上一步修改属性时设置writable为true的话，到这一步还可修改writable和value值
//     value: "koa",
//     writable : false,
//     enumerable : true,
//     configurable : false
// });

Object.defineProperties(object, descriptors) // 添加或更改多个对象属性
Object.getOwnPropertyNames(object) // 将所有属性作为数组返回
Object.keys(object) // 将可枚举属性作为数组返回
Object.getPrototypeOf(object) // 访问原型
Object.preventExtensions(object) // 防止向对象添加属性
Object.isExtensible(object) // 如果可以将属性添加到对象，则返回 true
Object.seal(object) // 防止更改对象属性（而不是值）
Object.isSealed(object) // 如果对象被密封，则返回 true
Object.freeze(object) // 防止对对象进行任何更改
Object.isFrozen(object) // 如果对象被冻结，则返回 true

function Person(name) {
　　this.name =name;
}
Person.prototype.showName=function(){
　　console.log('父类', this.name);
}
-------------------------------------------------------
上面的类和方法也可写为（写法不统一）
function Person(name) {
　　this.name =name;
　　this.showName=function(){
　　　　console.log('父类', this.name);
　　}
}
----------------------------------------------------------------
let p = new Person('cx');
p.showName(); //输出cx

function Worker(name, job) {
　　Person.call(this, name); //父类属性继承，这里的this指的是Worker对象，把父类所有地方属性如name都加到this所指的子类worker对象上
　　this.job = job; //再给子类加自己的属性
}
Worker.prototype = new Person();//父类方法的继承,把父类的实例赋值给子类的prototype，子类就有父类的一些东西
Worker.prototype.constructor = Worker; //继承父类会破坏子类的constructor属性，需要重新把子类赋值给constructor
Worker.prototype.showJob = function(){ //然后再声明子类的方法
　　　console.log('子类job：', this.job);
}
let obj = new Worker('cdf', 'it');
obj.showName();
obj.showJob();

class Person {
　　constructor(name) {
　　　　this.name = name;
　　}
　　showName() {
　　　　console.log('父类name:', this.name);
　　}
}
class Worker extends Person { //使用专门关键字extends继承父类方法
　　constructor(name, job) {
　　　　super(name); //使用super继承父类属性
　　　　this.job = job; //声明自己的属性
　　}
　　showJob() { //声明自己的方法
　　　　console.log('子类job:', this.job);
　　}
}
let obj = new Worker('cdf', 'it');
obj.showName();
obj.showJob();

export let height=172;
export let name='cdf';
// 一次性导一批变量
let age = 32;
let weight= '64kg';
export {age, weight};
let sqrt = Math.sqrt;
export default sqrt; //导出默认函数
export const sub = (a, b) => a + b;//导出函数

//*就是全部，把模块里所有输出成员全部引进来，起一个名字叫mod1，./mod1即./mod1.js，'.js'可不写，默认都是.js
import * as mod from "../../../model/mol1.js"
import { name } from "../../../model/mol1.js" //按需引入name成员
import { weight, height as myHeight} from "../../../model/mol1.js" //按需引入weight, 按需引入height时起别名
import sqrt,  { sub } from "../../../model/mol1.js"  //引入默认成员和其它非默认成员

  console.log('一次性引入所有成员:', mod);
  console.log('只引入一个name成员:', name);
  console.log('引入weight、height多个成员:', weight, myHeight);
  console.log('引入默认函数sqrt:', sqrt(49));
  console.log('引入其它非默认函数:', sub(1, 3));

let p= await import('./mod1.js'); //这是一个promise，等待引完了就能使用模块里的东西

import 'filename'

let arr = [19, 13, 15];
arr.sort(function(a, b){
　　return a-b;
})

arr.sort((a, b) => {
　　return a-b;
})

function show(n, fn) {
　　alert(fn(n)); //fn接收n参数
}

show(2, function(n) {
　　return n+2;
})

show(2, n=>n+2);

let json={
　　a:12,
　　fn:function(){ //里面的this为当前执行对象，若改为箭头函数，则this为window对象
　　　　console.log("this:", this); 
　　　　console.log("this.a:",this.a);
　　}
}
json.fn();  //输出12，this为当前json对象
let dateObj = new Date();
dateObj.fn=json.fn;
dateObj.fn(); //undifined，this为当前执行对象Date
let json2 = {
　　a:12,
　　fn:() => { //里面的this为当前环境
　　　　console.log("箭头函数this:", this); 
　　　　console.log("箭头函数this.a:",this.a);
　　}
}
json2.fn();  
let dateObj2 = new Date();
dateObj2.fn = json2.fn;
dateObj2.fn(); 

const test = (a='a', b='b', c='c')=>{
    return a+b+c
}
console.log(test('A','B')) //ABc

let name = 'cx';
const str = `Your name is ${name}`;
console.log(str) //Your name is cx

let {name, age} = {name:'cdf', age:20};
alert(name+'----'+age);

let  [name, age] = ['cdf', 20];
alert(name+'----'+age);

function show(a, ...b) { //第一个叫声明的参数，第二个叫剩余参数，剩余参数只能放在最后一位
　　console.log(b);    //[23, 46]
}
show(12, 23, 46); //a接收第一个参数，b接收剩余参数

let arr = [12, 34];
function show(a,b) {
　　alert(a +'-'+b);
}
show(...arr); //类似于show(12, 34);

let arr1 = [12,34];
let arr2 =[ 1,4,6,7];
let arr = [...arr1, ...arr2]; 
alert(arr); //12,34,1,4,6,7

let json1 = {name:'cdf', age:32};
let json2 = {...json1, height:176};
console.log(json2); //{name: "cdf", age: 32, height: 176}

let name = "admin";
let age = 18;
let obj = {
    name, //以前写为name : name,
    age
}

let obj2 = {
    name,
    say(){  //以前写为say : function () {
        console.log(this);
    }
}

let p1 = new Promise(function(resolve, reject){    
　　$.ajax({
　　　　url:'./data/1.txt',
　　　　type:'get',
　　　　dataType:'json',
　　　　success(arr){
　　　　　　resolve(arr) //成功执行resolve函数
　　　　},
　　　　error(err){
　　　　　　reject(err)
　　　　}
　　})
})
p1.then(function(data){ //上面的resolve就是这个匿名函数，data就是success里的arr，这里是对结果进行处理
　　console.log(data);
},function(data){})

<button id="a">事件a</button>
<button id="b">事件b</button>
let btnObj = document.getElementsByTagName('button');
for(var i=0;i<btnObj.length;i++) {
　　btnObj[i].onclick=function(){
　　　　alert(i);
　　}
}

let btnObj = document.getElementsByTagName('button');
for(var i = 0; i < btnObj.length; i++) {
　　(function(i) {
　　　　 btnObj[i].onclick=function(){
            alert(i);
　　　　 }
　　})(i);
}

for(let i=0;i<btnObj.length;i++) {
　　btnObj[i].onclick=function(){
　　　　alert(i);
　　}
}