vue wangEditor富文本编辑器默认显示与自定义工具栏配置-CFANZ编程社区

ajax

ajax一个前后台配合的技术，它可以让javascript发送http请求，与后台通信，获取数据和信息。ajax技术的原理是实例化xmlhttp对象，使用此对象与后台通信。jquery将它封装成了一个函数$.ajax()，我们可以直接用这个函数来执行ajax请求。

ajax需要在服务器环境下运行。

$.ajax使用方法
常用参数：
1、url 请求地址
2、type 请求方式，默认是’get’，常用的还有’post’
3、dataType 设置返回的数据格式，常用的是’json’格式，也可以设置为’text’
4、data 设置发送给服务器的数据
5、success 设置请求成功后的回调函数
6、error 设置请求失败后的回调函数
7、async 设置是否异步，默认值是’true’，表示异步

以前的写法：

$.ajax({
    url: '/change_data',
    type: 'get',
    dataType: 'json',
    data:{'code':300268}
    success:function(dat){
        alert(dat.name);
    },
    error:function(){
        alert('服务器超时，请重试！');
    }
});

新的写法(推荐)：

$.ajax({
    url: '/change_data',
    type: 'get',
    dataType: 'json',
    data:{'code':300268}
})
.done(function(dat) {
    alert(dat.name);
})
.fail(function() {
    alert('服务器超时，请重试！');
});

$(function(){
			
			/*$.ajax({
				url:'js/data.json',
				type:'get',
				dataType:'json'
				/*success:function(dat){
					// console.log(dat);
					$('.login_btn').hide();
					$('.login_info em').html( dat.name ).parent().show();
				},
				error:function(){
					alert('服务器超时，请重试！');
				}
			
			
			}).done(function(dat){
				$('.login_btn').hide();
				$('.login_info em').html( dat.name ).parent().show();
			}).fail(function(){
				alert('服务器超时，请重试！');
			})
			*/
			// 上面是完整写法，可以简写成下面$.get的写法：
			
			$.get('js/data.json',function(dat){
				$('.login_btn').hide();
				$('.login_info em').html( dat.name ).parent().show();
			});

		})

ES6语法

ES6是JavaScript语言的新版本，它也可以叫做ES2015，之前学习的JavaScript属于ES5，ES6在它的基础上增加了一些语法，ES6是未来JavaScript的趋势，而且React库中大量使用了ES6的语法，所以掌握这些常用的ES6语法是必须的。

变量声明let和const

let和const是新增的声明变量的开头的关键字，在这之前，变量声明是用var关键字，这两个关键字和var的区别是，它们声明的变量没有预解析，let和const的区别是，let声明的是一般变量，const申明的常量，不可修改。

alert(iNum01) // 弹出undefined
// alert(iNum02); 报错，let关键字定义变量没有变量预解析
// alert(iNum03); 报错，const关键字定义变量没有变量预解析

var iNum01 = 6;
// 使用let关键字定义变量
let iNum02 = 12;
// 使用const关键字定义变量
const iNum03 = 24;

alert(iNum01); // 弹出6
alert(iNum02); // 弹出12
alert(iNum03); // 弹出24

iNum01 = 7;
iNum02 = 13;
//iNum03 = 25; // 报错,const定义的变量不可修改,const定义的变量是常量

alert(iNum01)
alert(iNum02); 
alert(iNum03);

示例

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<script>
    // 用var定义变量，变量有预解析的特性
    // alert(iNum01);//undefined

    var iNum01 = 12;

    // alert(iNum01); //12

    //let定义的变量没有预解析，下面这一句就报错 在初始化之前无法访问'iNum02'
    // alert(iNum02); //Cannot access 'iNum02' before initialization 
    let iNum02 = 24; 
    // alert(iNum02); //24

    iNum02 =25;
    // alert(iNum02);//25

    //const定义的变量没有预解析，下面这一句出错 在初始化之前无法访问'iNum03'
    // alert(iNum03);//Cannot access 'iNum03' before initialization

    const iNum03 = 36;
    alert(iNum03); //36

    //对常量变量赋值。const定义的是常量，它的值不能修改，下面这一句出错
    // iNum03 = 37;
    
    // alert(iNum03);//Assignment to constant variable.
</script>
<body>
    
</body>
</html>

解构赋值

ES6 允许我们按照一定模式，从数组和对象中提取值，对变量进行赋值，这被称为解构（Destructuring）

1、数组的解构赋值

const arr = [1, 2, 3] 
let [a, b, c] = arr 
console.log(a, b, c); // 1 2 3

2、对象的解构赋值

const obj = { name: 'tom',address:'beijing', age: '100'} 
let {name, age} = obj  // 变量名称必须和对象的key同名
console.log(name, age); //tom 100

3、函数参数的解构赋值

const person = { name: '小明', age: 11}
function printPerson({name, age}) { // 函数参数可以解构一个对象
  console.log(`姓名：${name} 年龄：${age}`);
}
printPerson(person) // 姓名：小明 年龄：11

字符串模板

ES6中提供了模版字符串，用`（反引号）标识，用${}将变量括起来

let name = '小明';
let age = 11;
alert(`我的名字是${name},我的年龄是${age}岁。`)

示例

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script>
        //数组的解构赋值
        let aList = [1,2,3];
        let [a,b,c] = aList;
        console.log(a,b,c);//1 2 3

        // 对象的解构赋值
        let person = {name:"tom",age:18};
        let {name,age} = person;
        console.log(`姓名:${name} 年龄：${age}`);//姓名:tom 年龄：18

        // 函数参数的解构赋值

        function fnAlertPerson({name,age}){
            console.log(`我的姓名:${name} 我的年龄：${age}`);
            alert(
            `我的名字是：${name},
            我的年龄是：${age}`
            );
        }
        fnAlertPerson(person); //我的姓名:[object Object] 我的年龄：undefined
    </script>
</head>
<body>
    
</body>
</html>

扩展运算符(…)

扩展运算符（…），它用于把一个数组转化为用逗号分隔的参数序列，它常用在不定参数个数时的函数调用，数组合并等情形。

let arr = [1,2,3];
let arr2 = [...arr,4];
console.log(arr2)  // [1,2,3,4]

function fnAdd(a,b,c){
    alert(a + b + c);
}
fnAdd(...arr); // 6

function fnMyalert(...a){
    console.log(a);
    alert(a[0]);
    alert(a[1]);
}
fnMyalert(10,5); // [10,5]  10  5

示例

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script>
        let arr = [1,2,3];

        //下面这种方式不能复制数组
        let arr2 = arr; //只是指向同一个地址

        

        //用for循环赋值数组
        let arr3 = [];
        for (var index = 0; index < arr.length; index++) {
            arr3.push(arr[index]);
        }

       

        //通过扩展运算符复制数组
        let arr4 = [...arr,5];

        arr.push(4);
        // alert(arr); //1 2 3 4
        // alert(arr2); //1,2,3,4
        // alert(arr3); //1 2 3
        alert(arr4); // 1 2 3 5

        function fnAdd(a,b,c){
            alert(a+b+c);
        }

        // fnAdd(...arr);  //6 把数据arr传进去

        function fnConsole(...a){ //10,5,6
            console.log(a);
        }

        fnConsole(10,5,6);
    </script>
</head>
<body>
    
</body>
</html>

箭头函数

可以把箭头函数理解成匿名函数的第二种写法，箭头函数的作用是可以在对象中绑定this，解决了JavaScript中this指定混乱的问题。

// 定义函数的一般方式
/*
function fnRs(a,b){
    var rs = a + b;
    alert(rs);
}
fnRs(1,2);        
*/

// 通过匿名函数赋值来定义函数
/*
var fnRs = function(a,b){
    var rs = a + b;
    alert(rs);
}
fnRs(1,2);
*/

// 通过箭头函数的写法定义
var fnRs = (a,b)=>{
    var rs = a + b;
    alert(rs);
}        
// fnRs(1,2);

// 一个参数可以省略小括号
var fnRs2 = a =>{
    alert(a);
}
fnRs2('haha!');

// 函数中如果只有一个return语句，return和大括号都可以省略
/*
var fnAdd = function(a,b){
    return a + b;
}
*/
var fnAdd = (a,b) => a+b;


// 函数的返回值如果是javascript对象时，对象需要加括号
/*
let fn = function(){
    return {"a":5};
}
*/
// fn = ()=>{"a":5}
// 上面这么写是错的，需要写成下面的形式，返回的对象要加括号
fn = ()=>({"a":5})

示例

// 箭头函数的作用，可以绑定对象中的this
var person = {
    name:'tom',
    age:18,
    showName:function(){
        setTimeout(()=>{
            alert(this.name);
        },1000)            
    }
}
person.showName();

模块导入import和导出export

javascript之前是没有模块的功能的，之前做js模块化开发，是用的一些js库来模拟实现的，在ES6中加入了模块的功能，一个js文件就是一个模块，js文件中需要先导出(export)后，才能被其他js文件导入(import)

ES6的导出分为名字导出和默认导出
1、名称导出
导入的变量名必须和导出的变量名一致

// mod01.js文件中导出
export let iNum01 = 12;
export let fnMyalert = function(){
    alert('hello');
}

// index.html文件中导入
<script type="module">
    import {iNum01,fnMyalert} from "./js/mod01.js";
    alert(iNum01);
    fnMyalert();
</script>

// mod01.js中还可以写成如下：
let iNum01 = 12;
let fnMyalert = function(){
    alert('hello');
}
export {iNum01,fnMyalert}

2、默认导出(default export) 一个模块只能有一个默认导出，对于默认导出，导入的名称可以和导出的名称不一致，这对于导出匿名函数或类非常有用。

// mod02.js文件中导出
export default {"name":"tom","age":18}

// index.html文件中导入
<script type="module">
    import person from "./js/mod02.js";
    alert(person.name);
</script>

对象的简写
javascript对象在ES6中可以做一些简写形式，了解这些简写形式，才能方便我们读懂一些在javascript代码中简写的对象。

let name = '李思';
let age = 18;

/*
var person = {
    name:name,
    age:age,
    showname:function(){
        alert(this.name);
    },
    showage:function(){
        alert(this.age);
    }
}
*/

// 简写成下面的形式

var person = {
    name,
    age,
    showname(){
      alert(this.name);
    },
    showage(){
      alert(this.age);
    }
}

person.showname();
person.showage();

示例

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=\, initial-scale=1.0">
    <title>Document</title>
    <script>
        let name = "tom";
        let age = 18;

        // let person = {
        //     name:name,
        //     age:age,
        //     showname:function(){
        //         console.log(this.name);
        //     },

        //     showage:function(){
        //         console.log(this.age);
        //     }
        // }


        //上面对象可以简写成下面的形式
        let person = {
            name,
            age,
            showname(){
                console.log(this.name);
            },

            showage(){
                console.log(this.age);
            }
        }
        person.showname();

        person.showage();
    </script>
</head>
<body>
    
</body>
</html>

定义类及类的继承

ES6 封装了class语法来大大简化了类的创建和类的继承

// 定义类，类的首字母要大写
class Person {
    // 定义构造函数
    constructor(name,age){
        this.name = name;
        this.age = age;
    }
    // 定义方法
    showname(){
        alert('我的名字是：' + this.name);
    }
    showage(){
        alert('我的年龄是：' + this.age);
    }
}

// 通过类实例化对象
let Andy = new Person('刘德华',55);

// 调用对象的方法
Andy.showname();
Andy.showage();

// 定义类继承Person类
class Student extends Person{
    constructor(name,age,school){
        super(name,age);
        this.school = school;
    }
    showschool(){
        alert('我的学校是：' + this.school);
    }
}

// 通过类实例化对象
let Tom = new Student('小明','16','北京一中');

// 调用对象的方法
Tom.showname();
Tom.showschool();

示例

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script>
        //定义一个类
        class Person{
            constructor(name,age){
                this.name = name;
                this.age = age;
            }

            showname(){
                console.log("我的名称:"+this.name);
            }

            showage(){
                console.log("我的年龄:"+this.age);
            }
        }

        //通过类来实例化一个对象
        let Andy = new Person('刘德华',55);

        //调用对象上面的方法
        // Andy.showname();
        // Andy.showage();

        //定义类继承Person

        class Student extends Person{
            constructor(name,age,school){
                super(name,age);
                this.school = school;
            }

            showschool(){
                console.log("我的学校是:"+this.school);
            }
        }

        var xiaoming = new Student("小明",15,"武汉一中");

        xiaoming.showage();
        xiaoming.showname();
        xiaoming.showschool();
    </script>
</head>
<body>
    
</body>
</html>

异步操作

es6新增了异步操作的写法，来解决异步操作函数回调的问题，这个新增的写法就是Promise对象，Promise实际上就是一个特殊的Javascript对象，反映了”异步操作的最终值”。”Promise”直译过来有预期的意思，因此，它也代表了某种承诺，即无论你异步操作成功与否，这个对象最终都会返回一个值给你。
在实际开发中，如果我们在写ajax程序时，我们如果希望两个ajax程序都执行完后，再去做一件事情，我们实现的方法可以是，在一个ajax中嵌套另外一个ajax程序：

$.ajax({
    url:'data01.json',
    type:'get',
    dataType:'json',
    success:function(dat1){
        $.ajax({
            url:'data01.json',
            type:'get',
            dataType:'json',
            success:function(dat2){
                console.log([dat1,dat2])
            }
        })
})

上面的写法不方便编写，也不方便阅读，Promise对象就可以解决这个问题

// 实例化一个Promise对象
var pro01 = new Promise(function(resolve,reject){
    $.ajax({
        url:'js/data01.json',
        type:'get',
        dataType:'json'
    }).done(function(dat){
        resolve(dat)
    }).fail(function(err){
        reject(err)
    })
});

var pro02 = new Promise(function(resolve,reject){
    $.ajax({
        url:'js/data02.json',
        type:'get',
        dataType:'json'
    }).done(function(dat){
        resolve(dat)
    }).fail(function(err){
        reject(err)
    })
});

// 通过Promise对象来处理回调
pro01.then(function(dat){
    console.log(dat);
}).catch(function(err){
    console.log(err)
})

上面将两个ajax请求分别放在两个promise对象中，其中resolve参数是处理请求成功的回调函数，reject是处理失败的回调函数，接着就可以通过这个对象，来处理ajax的回调，相当于把回调拆开了写。如果希望两个ajax程序都执行完后，再去做一件事情，可以写成如下的形式：

Promise.all([pro01,pro02]).then(result=>console.log(result));

示例

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script src="js/jquery-1.12.4.min.js"></script>

    <script>

        //方式一
        // $.ajax({
        //     url:'js/data01.json',
        //     type:'get',
        //     dataType:'json',
        //     success: function(dat01){
        //         // console.log(dat); //{"name": "张三"}

        //         $.ajax({
        //             url:'js/data02.json',
        //             type:'get',
        //             dataType:'json',
        //             success: function(dat02){
        //                 // console.log(dat); //{"name": "张三"}
        //                 console.log([dat01,dat02]);
        //             },
        //             error: function(err){

        //             }
        //         })
        //     },
        //     error: function(err){

        //     }
        // })

        //方式二
        let pro01 = new Promise(function(resolve,reject){
            $.ajax({
                url:'js/data01.json',
                type:'get',
                dataType:'json',
                success:function(dat){
                    resolve(dat);
                },
                error:function(err){
                    reject(err);
                }
            })
        });

        let pro02 = new Promise(function(resolve,reject){
            $.ajax({
                url:'js/data02.json',
                type:'get',
                dataType:'json',
                success:function(dat){
                    resolve(dat);
                },
                error:function(err){
                    reject(err);
                }
            })
        });

        //then请求成功
        pro01.then(function(dat){
            console.log(dat);
        }).catch(function(err){

        })

        Promise.all([pro01,pro02]).then(re=>{
            console.log(re);
        })
    </script>
</head>
<body>
    
</body>
</html>

server.js

/*
NodeJS Static Http Server - http://github.com/thedigitalself/node-static-http-server/
By James Wanga - The Digital Self
Licensed under a Creative Commons Attribution 3.0 Unported License.

A simple, nodeJS, http development server that trivializes serving static files.

This server is HEAVILY based on work done by Ryan Florence(https://github.com/rpflorence) (https://gist.github.com/701407). I merged this code with suggestions on handling varied MIME types found at Stackoverflow (http://stackoverflow.com/questions/7268033/basic-static-file-server-in-nodejs).

To run the server simply place the server.js file in the root of your web application and issue the command 
$ node server.js 
or 
$ node server.js 1234 
with "1234" being a custom port number"

Your web application will be served at http://localhost:8888 by default or http://localhost:1234 with "1234" being the custom port you passed.

Mime Types:
You can add to the mimeTypes has to serve more file types.

Virtual Directories:
Add to the virtualDirectories hash if you have resources that are not children of the root directory

*/
var http = require("http"),
    url = require("url"),
    path = require("path"),
    fs = require("fs")
    port = process.argv[2] || 8888;

var mimeTypes = {
    "htm": "text/html",
    "html": "text/html",
    "jpeg": "image/jpeg",
    "jpg": "image/jpeg",
    "png": "image/png",
    "gif": "image/gif",
    "js": "text/javascript",
    "css": "text/css",
    "json":"text/json"
  };

var virtualDirectories = {
    //"images": "../images/"
  };

http.createServer(function(request, response) {

  var uri = url.parse(request.url).pathname
    , filename = path.join(process.cwd(), uri)
    , root = uri.split("/")[1]
    , virtualDirectory;
  
  virtualDirectory = virtualDirectories[root];
  if(virtualDirectory){
    uri = uri.slice(root.length + 1, uri.length);
    filename = path.join(virtualDirectory ,uri);
  }

  fs.exists(filename, function(exists) {
    if(!exists) {
      response.writeHead(404, {"Content-Type": "text/plain"});
      response.write("404 Not Found\n");
      response.end();
      console.error('404: ' + filename);
      return;
    }

	if (fs.statSync(filename).isDirectory()) filename += '/index.html';

    fs.readFile(filename, "binary", function(err, file) {
      if(err) {        
        response.writeHead(500, {"Content-Type": "text/plain"});
        response.write(err + "\n");
        response.end();
        console.error('500: ' + filename);
        return;
      }

      var mimeType = mimeTypes[path.extname(filename).split(".")[1]];
      response.writeHead(200, {"Content-Type": mimeType});
      response.write(file, "binary");
      response.end();
      console.log('200: ' + filename + ' as ' + mimeType);
    });
  });
}).listen(parseInt(port, 10));

console.log("Static file server running at\n  => http://localhost:" + port + "/\nCTRL + C to shutdown");

data01.json和data02.json示例

{"name":"张三"}  {"name":"李思"}

使用node server.js

新增数组操作方法

map() 方法
map方法可以分别处理数组中的成员，返回一个新数组，也可以用于遍历数组

let aList = [1,2,3];

aList.map(function(a){
    alert(a);
})

//  弹出 1  2   3

concat() 方法

concat() 方法用于连接新的数组成员或者其他数组，返回一个新的数组

let aList01 = [1,2,3];
let aList02 = ['a','b'];
let aList03 = arr.concat(4,5);
let aList04 = aList01.concat(aList02);

console.log(aList03) // [1,2,3,4,5]
console.log(aList04) // [1,2,3,'a','b']

示例

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>

    <script>
        var aList = ['a','b','c'];
        //第一个参数数组成员值，第二个参数是成员的索引值
        aList.map((item,i)=>{
            console.log(item+" | "+i);
        })

        //concat会返回一个新的数组
        var aList2 = aList.concat('d','f');
        var aList3 = [1,2];

        var aList4 = aList.concat(aList3);

        console.log(aList2);
        console.log(aList4);
    </script>
</head>
<body>
    
</body>
</html>