共计 16098 个字符,预计需要花费 41 分钟才能阅读完成。
在过来几年里,JavaScript 有很多的更新。如果你想晋升写代码的能力,这些更新将会对你有十分大的帮忙。
对于程序员来说,理解这门语言的最新倒退是十分重要的。它能使你跟上最新趋势,进步代码品质,在工作中超群绝伦,从而进一步晋升你的薪资待遇。
特地地,如果你想学习像 React、Angular 或 Vue 这样的框架,你必须把握这些最新的个性。
最近,JavaScript 减少了许多有用的性能,比方Nullish coalescing operator, optional chaining, Promises, async/await, ES6 destructuring, 等等。
那么当初,咱们将探讨每个 JavaScript 开发者都应该晓得的概念。
JavaScript 中的 Let 和 const
在 ES6 之前,JavaScript 应用 var 关键字来申明变量,var 只有全局作用域和函数作用域,所谓全局作用域就是在代码的任何地位都能拜访 var 申明的变量,而函数作用域在变量申明的以后函数外部拜访变量。此时是没有块级作用域的。
随着 let 和 const 这两个关键字的增加,JS 减少了块级作用域的概念。
如何在 JavaScript 中应用 let
当咱们在用 let 申明变量时,用于申明一次之后就不能再以雷同的名称从新申明它。
// ES5 Code
var value = 10;
console.log(value); // 10
var value = "hello";
console.log(value); // hello
var value = 30;
console.log(value); // 30
如上所示,咱们屡次应用 var 关键字从新申明了变量值。
在 ES6 之前,咱们能够应用 var 从新申明之前曾经申明过的变量,这就会导致了一个问题:如果咱们在不知情的状况下,在其余中央从新申明了该变量,很有可能会笼罩原先变量的值,造成一些难以调试的问题。
所以,Let 解决很好地解决此问题。当你应用 let 从新申明变量值时,将会报错。
// ES6 Code
let value = 10;
console.log(value); // 10
let value = "hello"; // Uncaught SyntaxError: Identifier 'value' has already been declared
然而,以下代码是非法的:
// ES6 Code
let value = 10;
console.log(value); // 10
value = "hello";
console.log(value); // hello
咱们发现下面的代码看起来没什么问题,是因为咱们从新给 value 变量赋了一个新值,然而并没有从新申明。
咱们来看下上面的代码:
// ES5 Code
var isValid = true;
if(isValid) {
var number = 10;
console.log('inside:', number); // inside: 10
}
console.log('outside:', number); // outside: 10
如上所示,在应用 var 申明变量时,能够在 if 块之外拜访该变量。
而应用 let 申明的 number 变量只能在 if 块内拜访,如果在 if 块外拜访将会报错。
咱们来看下接下来的代码
// ES6 Code
let isValid = true;
if(isValid) {
let number = 10;
console.log('inside:', number); // inside: 10
}
console.log('outside:', number); // Uncaught ReferenceError: number is not defined
如上述代码所示,应用 let 别离在 if 块内、if 块外申明了 number 变量。在 if 块外,number 无奈被拜访,因而会呈现援用谬误。
然而,如果变量 number 在 if 块外曾经申明,将会呈现上面的后果。
// ES6 Code
let isValid = true;
let number = 20;
if(isValid) {
let number = 10;
console.log('inside:', number); // inside: 10
}
console.log('outside:', number); // outside: 20
当初在独自的范畴内有两个 number 变量。在 if 块外,number 的值为 20。
// ES5 Code
for(var i = 0; i < 10; i++){console.log(i);
}
console.log('outside:', i); // 10
当应用 var 关键字时,i 在 for 循环之外也能够拜访到。
// ES6 Code
for(let i = 0; i < 10; i++){console.log(i);
}
console.log('outside:', i); // Uncaught ReferenceError: i is not defined
而应用 let 关键字时,在 for 循环内部是不可拜访的。
因而,正如上述示例代码所示,let 申明的变量只能在块外部可用,而在块内部不可拜访。
咱们能够应用一对大括号创立一个块,如下:
let i = 10;
{
let i = 20;
console.log('inside:', i); // inside: 20
i = 30;
console.log('i again:', i); // i again: 30
}
console.log('outside:', i); // outside: 10
后面有提到,let 在同一个块中不能从新申明变量,不过能够在另一个块中从新申明。如上代码所示,咱们在块内从新申明了 i,并赋值 20,该变量仅可在该块中应用。
在块外,当咱们打印变量时,咱们失去的是 10 而不是之前调配的值,这是因为块外,外部变变量 i 是不存在的。
如果在块外未声明变量,那么将会报错:
{
let i = 20;
console.log('inside:', i); // inside: 20
i = 30;
console.log('i again:', i); // i again: 30
}
console.log('outside:', i); // Uncaught ReferenceError: i is not defined
如何在 JavaScript 应用 const
const 关键字在块级作用域中的工作形式与 let 关键字完全相同。因而,咱们来看下他们的区别。
const 申明的变量为常量,其值是不能扭转的。而 let 申明的变量,能够为其赋一个新值,如下所示:
let number = 10;
number = 20;
console.log(number); // 20
然而以下状况,咱们不能这样应用 const。
const number = 10;
number = 20; // Uncaught TypeError: Assignment to constant variable.
咱们甚至不能应用 const 像上面一样从新申明。
const number = 20;
console.log(number); // 20
const number = 10; // Uncaught SyntaxError: Identifier 'number' has already been declared
当初,看上面的代码:
const arr = [1, 2, 3, 4];
arr.push(5);
console.log(arr); // [1, 2, 3, 4, 5]
咱们说过 const 申明的常量,它的值永远不会扭转——然而咱们扭转了下面的常量数组并没有报错。这是为什么呢?
留神: 数组是援用类型,而不是 JavaScript 的根本类型
理论存储在 arr 中的不是数组,而是数组存储的内存地位的援用(地址)。执行 arr.push(5),并没有扭转 arr 指向的援用,而是扭转了存储在那个援用上的值。
对象也是如此:
const obj = {
name: 'David',
age: 30
};
obj.age = 40;
console.log(obj); // {name: 'David', age: 40}
这里,咱们也没有扭转 obj 指向的援用,而是扭转了存储在援用的值。
因而,上述的代码将会起作用,但上面的代码是有效的。
const obj = {name: 'David', age: 30};
const obj1 = {name: 'Mike', age: 40};
obj = obj1; // Uncaught TypeError: Assignment to constant variable.
这样写会抛出异样,因为咱们试图更改 const 变量指向的援用。
因而,在应用 const 时要记住一点:应用 const 申明常量时,不能从新申明,也不能从新赋值。如果申明的常量是援用类型,咱们能够更改存储在援用的值。
同理,上面的代码也是有效的。
const arr = [1, 2, 3, 4];
arr = [10, 20, 30]; // Uncaught TypeError: Assignment to constant variable.
总结:
- 关键字 let 和 const 在 JavaScript 中增加块级作用域。
- 当咱们将一个变量申明为 let 时,咱们不能在同一作用域 (函数或块级作用域) 中从新定义或从新申明另一个具备雷同名称的 let 变量,然而咱们能够从新赋值。
- 当咱们将一个变量申明为 const 时,咱们不能在同一作用域 (函数或块级作用域) 中从新定义或从新申明具备雷同名称的另一个 const 变量。然而,如果变量是援用类型(如数组或对象),咱们能够更改存储在该变量中的值。
好了,咱们持续下一个话题: promises。
JavaScript 中的 promises
对于很多新开发者来说,promises 是 JavaScript 中较难了解的局部。ES6 中原生提供了 Promise 对象,那么 Promise 到底是什么呢?
Promise 对象代表了将来将要产生的事件,用来传递异步操作的音讯。
如何发明一个 promise
应用 promise 构造函数创立一个 promise,如下所示:
const promise = new Promise(function(resolve, reject) {});
Promise 的构造函数接管一个函数作为参数,并且在外部接管两个参数:resolve,reject。resolve 和 reject 参数实际上是咱们能够调用的函数,具体取决于异步操作的后果。
Promise 有三种状态:
- pending: 初始状态,不是胜利或失败状态。
- fulfilled: 示意操作胜利实现。
- rejected: 示意操作失败。
当咱们创立 Promise 时,它处于期待的状态。当咱们调用 resolve 函数时,它将进入已实现状态。如果调用 reject,他将进入被回绝状态。
在上面的代码中,咱们执行了一个异步操作,也就是 setTimeout,2 秒后,调用 resolve 办法。
const promise = new Promise(function(resolve, reject) {setTimeout(function() {
const sum = 4 + 5;
resolve(sum);
}, 2000);
});
咱们须要应用以下办法注册一个回调.then 取得 1promise 执行胜利的后果,如下所示:
const promise = new Promise(function(resolve, reject) {setTimeout(function() {
const sum = 4 + 5;
resolve(sum);
}, 2000);
});
promise.then(function(result) {console.log(result); // 9
});
then 接管一个参数,是函数,并且会拿到咱们在 promise 中调用 resolve 时传的的参数。
如果操作不胜利,则调用 reject 函数:
const promise = new Promise(function(resolve, reject) {setTimeout(function() {
const sum = 4 + 5 + 'a';
if(isNaN(sum)) {reject('Error while calculating sum.');
} else {resolve(sum);
}
}, 2000);
});
promise.then(function(result) {console.log(result);
});
如果 sum 不是一个数字,那么咱们调用带有错误信息的 reject 函数,否则咱们调用 resolve 函数。
执行上述代码,输入如下:
调用 reject 函数会抛出一个谬误,然而咱们没有增加用于捕捉谬误的代码。
须要调用 catch 办法指定的回调函数来捕捉并解决这个谬误。
promise.then(function(result) {console.log(result);
}).catch(function(error) {console.log(error);
});
输入如下:
所以倡议大家在应用 promise 时加上 catch 办法,以此来防止程序因谬误而进行运行。
链式操作
咱们能够向单个 promise 增加多个 then 办法,如下所示:
promise.then(function(result) {console.log('first .then handler');
return result;
}).then(function(result) {console.log('second .then handler');
console.log(result);
}).catch(function(error) {console.log(error);
});
当增加多个 then 办法时,前一个 then 办法的返回值将主动传递给下一个 then 办法。
如上图所示,咱们在第一个 then 办法中输入字符串,并将接管的参数 result(sum)返回给下一个 result。
在下一个 then 办法中,输入字符串,并输入上一个 then 办法传递给它的 result。
如何在 JavaScript 中提早 promise 的执行
很多时候,咱们不心愿立刻创立 promise,而是心愿在某个操作实现后再创立。
咱们能够将 promise 封装在一个函数中,而后从函数中返回 promise,如下所示:
function createPromise() {return new Promise(function(resolve, reject) {setTimeout(function() {
const sum = 4 + 5;
if(isNaN(sum)) {reject('Error while calculating sum.');
} else {resolve(sum);
}
}, 2000);
});
}
这样,咱们就能够通过函数将参数传递给 promise,达到动静的目标。
function createPromise(a, b) {return new Promise(function(resolve, reject) {setTimeout(function() {
const sum = a + b;
if(isNaN(sum)) {reject('Error while calculating sum.');
} else {resolve(sum);
}
}, 2000);
});
}
createPromise(1,8)
.then(function(output) {console.log(output); // 9
});
// OR
createPromise(10,24)
.then(function(output) {console.log(output); // 34
});
此外,咱们只能向 resolve 或 reject 函数传递一个值。如果你想传递多个值到 resolve 函数,能够将它作为一个对象传递,如下:
const promise = new Promise(function(resolve, reject) {setTimeout(function() {
const sum = 4 + 5;
resolve({
a: 4,
b: 5,
sum
});
}, 2000);
});
promise.then(function(result) {console.log(result);
}).catch(function(error) {console.log(error);
});
如何在 JavaScript 中应用箭头函数
上述示例代码中,咱们应用惯例的 ES5 语法创立了 promise。然而,通常应用箭头函数代替 ES5 语法,如下:
const promise = new Promise((resolve, reject) => {setTimeout(() => {
const sum = 4 + 5 + 'a';
if(isNaN(sum)) {reject('Error while calculating sum.');
} else {resolve(sum);
}
}, 2000);
});
promise.then((result) => {console.log(result);
});
你能够依据本人须要应用 ES5 或 ES6 语法。
ES6 Import 和 Export 语法
在 ES6 之前,咱们在一个 HTML 文件中能够应用多个 script 标签来援用不同的 JavaScript 文件,如下所示:
<script type="text/javascript" src="home.js"></script>
<script type="text/javascript" src="profile.js"></script>
<script type="text/javascript" src="user.js"></script>
然而如果咱们在不同的 JavaScript 文件中有一个同名的变量,将会呈现命名抵触,你理论失去的可能并不是你冀望的值。
ES6 减少了模块的概念来解决这个问题。
在 ES6 中,咱们编写的每一个 JavaScript 文件都被称为模块。咱们在每个文件中申明的变量和函数不能用于其余文件,除非咱们将它们从该文件中导出并、在另一个文件中失去援用。
因而,在文件中定义的函数和变量是每个文件公有的,在导出它们之前,不能在文件内部拜访它们。
export 有两种类型:
- 命名导出: 在一个文件中能够有多个命名导出
- 默认导出: 单个文件中只能有一个默认导出
JavaScript 中的命名导出
如下所示,将单个变量命名导出:
export const temp = "This is some dummy text";
如果想导出多个变量,能够应用大括号指定要输入的一组变量。
const temp1 = "This is some dummy text1";
const temp2 = "This is some dummy text2";
export {temp1, temp2};
须要留神的是,导出语法不是对象语法。因而,在 ES6 中,不能应用键值对的模式导出。</pre>
// This is invalid syntax of export in ES6
export {key1: value1, key2: value2}
import 命令承受一对大括号,外面指定要从其余模块导入的变量名。
import {temp1, temp2} from './filename';
留神,不须要在文件名中增加.js 扩展名,因为默认状况下会思考该拓展名。
// import from functions.js file from current directory
import {temp1, temp2} from './functions';
// import from functions.js file from parent of current directory
import {temp1} from '../functions';
提醒一点,导入的变量名必须与被导入模块对外接口的名称雷同。
因而,导出应应用:
// constants.js
export const PI = 3.14159;
那么在导入的时候,必须应用与导出时雷同的名称:
import {PI} from './constants';
// This will throw an error
import {PiValue} from './constants';
如果想为输出的变量重新命名,能够应用 as 关键字,语法如下:
import {PI as PIValue} from './constants';
咱们认为 PI 重命名为 PIValue,因而不能再应用 PI 变量名。
导出时也可应用上面的重命名语法:
// constants.js
const PI = 3.14159;
export {PI as PIValue};
而后在导入是,必须应用 PIValue。
import {PIValue} from './constants';
命名导出某些内容之前必须先申明它。
export 'hello'; // this will result in error
export const greeting = 'hello'; // this will work
export {name: 'David'}; // This will result in error
export const object = {name: 'David'}; // This will work
咱们来看上面的 validations.js 文件:
// utils/validations.js
const isValidEmail = function(email) {if (/^[^@]+@[^@]+\.[^@ \.]{2,}$/.test(email)) {return "email is valid";} else {return "email is invalid";}
};
const isValidPhone = function(phone) {if (/^[\\(]\d{3}[\\)]\s\d{3}-\d{4}$/.test(phone)) {return "phone number is valid";} else {return "phone number is invalid";}
};
function isEmpty(value) {if (/^\s*$/.test(value)) {return "string is empty or contains only spaces";} else {return "string is not empty and does not contain spaces";}
}
export {isValidEmail, isValidPhone, isEmpty};
在 index.js 中,咱们能够应用如下函数:
// index.js
import {isEmpty, isValidEmail} from "./utils/validations";
console.log("isEmpty:", isEmpty("abcd")); // isEmpty: string is not empty and does not contain spaces
console.log("isValidEmail:", isValidEmail("abc@11gmail.com")); // isValidEmail: email is valid
console.log("isValidEmail:", isValidEmail("ab@c@11gmail.com")); // isValidEmail: email is invalid
JavaScript 的默认导出
如上所述,单个文件中最多只能有一个默认导出。然而,你能够在一个文件中应用多个命名导出和一个默认导出。
要申明一个默认导出,咱们须要应用以下语法:
//constants.js
const name = 'David';
export default name;
在导入时就不须要再应用花括号了。
import name from './constants';
如下,咱们有多个命名导出和一个默认导出:
// constants.js
export const PI = 3.14159;
export const AGE = 30;
const NAME = "David";
export default NAME;
此时咱们应用 import 导入时,只须要在大括号之前指定默认导出的变量名。
// NAME is default export and PI and AGE are named exports here
import NAME, {PI, AGE} from './constants';
应用 export default 导出的内容,在导入的时候,import 前面的名称能够是任意的。
// constants.js
const AGE = 30;
export default AGE;
import myAge from‘./constants’;
console.log(myAge); // 30
另外,export default 的变量名称从 Age 到 myAge 之所以可行,是因为只能存在一个 export default。因而你能够随便命名。还需注意的是,关键字不能在申明变量之前。
// constants.js
export default const AGE = 30; // This is an error and will not work
因而,咱们须要在独自的一行应用关键字。
// constants.js
const AGE = 30;
export default AGE;
不过以下模式是容许的:
//constants.js
export default {
name: "Billy",
age: 40
};
并且须要在另一个文件中应用它
import user from './constants';
console.log(user.name); // Billy
console.log(user.age); // 40
还有,能够应用以下语法来导入 constants.js 文件中导出的所有变量:
// test.js
import * as constants from './constants';
上面,咱们将导入所有咱们 constants.js 存储在 constants 变量中的命名和 export default。因而,constants 当初将成为对象。
// constants.js
export const USERNAME = "David";
export default {
name: "Billy",
age: 40
};
在另一个文件中,咱们按一下形式应用。
// test.js
import * as constants from './constants';
console.log(constants.USERNAME); // David
console.log(constants.default); // {name: "Billy", age: 40}
console.log(constants.default.age); // 40
也能够应用以下形式组合应用命名导出和默认导出:
// constants.js
const PI = 3.14159; const AGE = 30;
const USERNAME = "David";
const USER = {
name: "Billy",
age: 40
};
export {PI, AGE, USERNAME, USER as default};
import USER, {PI, AGE, USERNAME} from "./constants";
总而言之:
ES6 中,一个模块就是一个独立的文件,该文件外部的所有变量,内部都无奈获取。如果想从内部读取模块内的某个变量,必须应用 export 关键字导出该变量,应用 import 关键字导入该变量。
JavaScript 中的默认参数
ES6 减少了一个十分有用的个性,即在定义函数时提供默认参数。
假如咱们有一个应用程序,一旦用户登录零碎,咱们将向他们显示一条欢送音讯,如下所示:
function showMessage(firstName) {return "Welcome back," + firstName;}
console.log(showMessage('John')); // Welcome back, John
然而,如果数据库中没有用户名,那该怎么办呢? 所以,咱们首先须要查看是否提供了 firstName,而后再显示相应的信息。
在 ES6 之前,咱们必须写这样的代码:
function showMessage(firstName) {if(firstName) {return "Welcome back," + firstName;} else {return "Welcome back, Guest";}
}
console.log(showMessage('John')); // Welcome back, John
console.log(showMessage()); // Welcome back, Guest
但当初应用 ES6 提供的默认参数,咱们能够这样写:
function showMessage(firstName = 'Guest') {return "Welcome back," + firstName;}
console.log(showMessage('John')); // Welcome back, John
console.log(showMessage()); // Welcome back, Guest
函数的默认参数能够为任意值。
function display(a = 10, b = 20, c = b) {console.log(a, b, c);
}
display(); // 10 20 20
display(40); // 40 20 20
display(1, 70); // 1 70 70
display(1, 30, 70); // 1 30 70
在下面的代码中,咱们没有提供函数的所有参数,理论代码等同于:
display(); // 等同于 display(undefined, undefined, undefined)
display(40); 等同于 display(40, undefined, undefined)
display(1, 70); 等同于 display(1, 70, undefined)
因而,如果传递的参数是 undefined,则对应的参数将应用默认值。
咱们还能够将对象或计算值指定为默认值,如下:
const defaultUser = {
name: 'Jane',
location: 'NY',
job: 'Software Developer'
};
const display = (user = defaultUser, age = 60 / 2) => {console.log(user, age);
};
display();
/* output
{
name: 'Jane',
location: 'NY',
job: 'Software Developer'
} 30
*/
ES5 代码如下:
// ES5 Code
function getUsers(page, results, gender, nationality) {
var params = "";
if(page === 0 || page) {params += `page=${page}&`;
}
if(results) {params += `results=${results}&`;
}
if(gender) {params += `gender=${gender}&`;
}
if(nationality) {params += `nationality=${nationality}`;
}
fetch('https://randomuser.me/api/?' + params)
.then(function(response) {return response.json();
})
.then(function(result) {console.log(result);
})
.catch(function(error) {console.log('error', error);
});
}
getUsers(0, 10, 'male', 'us');
在这段代码中,咱们通过在 getUsers 函数中传递各种可选参数来进行 API 调用。在进行 API 调用之前,咱们增加了各种 if 条件来查看是否增加了参数,并基于此结构查问字符串,如下所示:
https://randomuser.me/api/? page=0&results=10&gender=male&nationality=us
应用 ES6 的默认参数则不用添这么多 if 条件,如下所示:
function getUsers(page = 0, results = 10, gender = 'male',nationality = 'us') {fetch(`https://randomuser.me/api/?page=${page}&results=${results}&gender=${gender}&nationality=${nationality}`)
.then(function(response) {return response.json();
})
.then(function(result) {console.log(result);
})
.catch(function(error) {console.log('error', error);
});
}
getUsers();
这样一来,代码失去了大量的简化,即使咱们不为 getUsers 函数提供任何参数时,它也能采纳默认值。当然,咱们也能够传递本人的参数:
getUsers(1, 20, 'female', 'gb');
它将笼罩函数的默认参数。
null 不等于未定义
留神: 定义默认参数时,null 和 undefined 是不同的。
咱们来看上面的代码:
function display(name = 'David', age = 35, location = 'NY'){console.log(name, age, location);
}
display('David', 35); // David 35 NY
display('David', 35, undefined); // David 35 NY
// OR
display('David', 35, undefined); // David 35 NY
display('David', 35, null); // David 35 null
当咱们传递 null 作为参数时,它理论是给 location 参数赋一个空值,与 undefined 不一样。所以它不会取默认值“NY”。</pre>
Array.prototype.includes
ES7 减少了数组的 includes 办法,用来判断一个数组是否蕴含一个指定的值,如果是返回 true,否则 false。
// ES5 Code
const numbers = ["one", "two", "three", "four"];
console.log(numbers.indexOf("one") > -1); // true
console.log(numbers.indexOf("five") > -1); // false
数组能够应用 includes 办法:
// ES7 Code
const numbers = ["one", "two", "three", "four"];
console.log(numbers.includes("one")); // true
console.log(numbers.includes("five")); // false
includes 办法能够使代码简短且易于了解,它也可用于比拟不同的值。
<pre style="line-height:18.0pt;
vertical-align:baseline">const day ="monday";</pre>
if(day === "monday" || day === "tuesday" || day === "wednesday") {// do something}
// 以上代码应用 include 办法能够简化如下:
const day = "monday";
if(["monday", "tuesday", "wednesday"].includes(day)) {// do something}
因而,在查看数组中的值时,应用 includes 办法将会十分的不便。
反对 ES6+ 的第三方组件
除了语法更新,开发者还需把握一些第三方组件,以便更好的实现我的项目交付。
例如,应用 SpreadJS 表格组件,能够向 JavaScript 应用程序增加高级电子表格性能,包含反对 450 多种计算公式、在线导入导出 Excel 文档、数据透视表和可视化剖析,以创立财务、剖析、估算 / 预测、数据收集、迷信和许多其余相似的应用程序。
如何在 Vue 中应用 SpreadJS
SpreadJS 能够通过以下两种形式与 Vue 一起应用:
- 应用 Node 包管理器:
关上命令提示符窗口并键入以下命令,应用 vue init webpack 创立一个简略的 Vue 我的项目:
$ npm install --global vue-cli
# create a new project using the "webpack" template
$ vue init webpack my-project
# install dependencies and go!
$ cd my-project
$ npm run dev
在我的项目中导入 SpreadJS Vue 模块:
$ npm install @grapecity/spread-sheets-vue
在 Vue 应用程序中应用 SpreadJS:
<template>
<div>
<gc-spread-sheets
:hostClass='hostClass'
>
<gc-worksheet
:dataSource="dataTable"
:autoGenerateColumns = 'autoGenerateColumns'
>
<gc-column
:width="width"
:dataField="'price'"
:visible = 'visible'
:formatter = 'formatter'
:resizable = 'resizable'
></gc-column>
</gc-worksheet>
</gc-spread-sheets>
</div>
</template>
<script>
import '@grapecity/spread-sheets/styles/gc.spread.sheets.excel2016colorful.css'
import '@grapecity/spread-sheets-vue'
export default {data(){
return {
hostClass:'spread-host',
autoGenerateColumns:true,
width:300,
visible:true,
resizable:true,
formatter:"$ #.00"
}
},
computed:{dataTable(){let dataTable = [];
for (let i = 0; i < 42; i++) {dataTable.push({price: i + 0.56})
}
return dataTable
}
}
}
</script>
<style scoped>
.spread-host {
width: 500px;
height: 600px;
}
</style>
- 应用传统 HTML
创立 HTML 页面,将 SpreadJS 和 Vue-SpreadJS 增加到 HTML 模板:增加援用 gc.spread.sheets.all....min.js, gc.SpreadJS....css 和 gc.spread.sheets.vue...*.js 文件到 HTML 模板 (i.e. 你的 index.html 文件)即可。
点击此处,理解更多 SpreadJS 在 Vue 的技术资源。
如何在 React 等框架应用 SpreadJS
与 Vue 相似,SpreadJS 也能够通过应用 Node 包管理器和传统 HTML 两种形式与 React 一起应用,点击此处,理解应用形式。
结语
从 ES6 开始,JavaScript 中产生许多变更。对于 JavaScript,Angular,React 或 Vue 开发人员都应该晓得它们。
理解这些变更能够使你成为更棒的开发者,甚至能够帮忙您取得更高的薪水。而且,如果你只是在学习 React 之类的库以及 Angular 和 Vue 之类的框架,那么您肯定要把握这些新个性。