开发者的生活总是在学习新的东西,跟上变化不应该比现在更难,我的动机是介绍所有 JavaScript 的最佳实践,比如简写功能,作为一个前端开发者,我们必须知道,让我们的生活在 2021 年变得更轻松。
你可能做了很长时间的 JavaScript 开发,但有时你可能没有更新最新的特性,这些特性可以解决你的问题,而不需要做或编写一些额外的代码。这些技术可以帮助您编写干净和优化的 JavaScript 代码。此外,这些主题可以帮助你为 2021 年的 JavaScript 面试做准备。
我们可以在数组中存储多个值,并且可以使用数组 include 方法。
- //Longhand
- if (
- x === "abc" ||
- x === "def" ||
- x === "ghi" ||
- x === "jkl"
- ) {
- //logic
- }
-
- //Shorthand
- if (["abc", "def", "ghi", "jkl"].includes(x)) {
- //logic
- }
这对于我们有 if-else 条件,里面不包含更大的逻辑时,是一个较大的捷径。我们可以简单的使用三元运算符来实现这个简写。
- // Longhand
- let test: boolean;
- if (x > 100) {
- test = true;
- } else {
- test = false;
- }
-
- // Shorthand
- let test = x > 10 ? true : false;
- //or we can use directly
- let test = x > 10;
- console.log(test);
当我们有嵌套条件时,我们可以采用这种方式。
- let x = 300,
- test2 =
- x > 100
- ? "greater 100"
- : x < 50
- ? "less 50"
- : "between 50 and 100";
- console.log(test2); // "greater than 100"
当我们要声明两个具有共同值或共同类型的变量时,可以使用此简写形式。
- //Longhand
- let test1;
- let test2 = 1;
-
- //Shorthand
- let test1,
- test2 = 1;
当我们创建新的变量时,有时我们想检查我们引用的变量的值是否为空或 undefined。JavaScript 确实有一个非常好的简写工具来实现这些功能。
- // Longhand
- if (test1 !== null || test1 !== undefined || test1 !== "") {
- let test2 = test1;
- }
-
- // Shorthand
- let test2 = test1 || "";
- let test1 = null,
- test2 = test1 || "";
-
- console.log("null check", test2); // output will be ""
- 6.undefined 值检查和分配默认值
- js
- let test1 = undefined,
- test2 = test1 || "";
-
- console.log("undefined check", test2); // output will be ""
正常值检查
- let test1 = "test",
- test2 = test1 || "";
-
- console.log(test2); // output: 'test'
当我们处理多个变量并希望将不同的值分配给不同的变量时,此简写技术非常有用。
- //Longhand
- let test1, test2, test3;
- test1 = 1;
- test2 = 2;
- test3 = 3;
-
- //Shorthand
- let [test1, test2, test3] = [1, 2, 3];
我们在编程中处理很多算术运算符,这是将运算符分配给 JavaScript 变量的有用技术之一。
- // Longhand
- test1 = test1 + 1;
- test2 = test2 - 1;
- test3 = test3 * 20;
-
- // Shorthand
- test1++;
- test2--;
- test3 *= 20;
这是我们大家都在使用的常用简写之一,但仍然值得一提。
- // Longhand
- if (test1 === true) or if (test1 !== "") or if (test1 !== null)
-
- // Shorthand //it will check empty string,null and undefined too
- if (test1)
注意:如果 test1 有任何值,它将在 if 循环后进入逻辑,该运算符主要用于 null 或 undefined 的检查。
如果仅在变量为 true 的情况下才调用函数,则可以使用 && 运算符。
- //Longhand
- if (test1) {
- callMethod();
- }
-
- //Shorthand
- test1 && callMethod();
这是迭代的常用简写技术之一。
- // Longhand
- for (var i = 0; i < testData.length; i++)
-
- // Shorthand
- for (let i in testData) or for (let i of testData)
每个变量的数组
- function testData(element, index, array) {
- console.log("test[" + index + "] = " + element);
- }
-
- [11, 24, 32].forEach(testData);
- // logs: test[0] = 11, test[1] = 24, test[2] = 32
我们也可以在 return 语句中使用比较。它将避免我们的 5 行代码,并将它们减少到 1 行。
- // Longhand
- let test;
- function checkReturn() {
- if (!(test === undefined)) {
- return test;
- } else {
- return callMe("test");
- }
- }
- var data = checkReturn();
- console.log(data); //output test
- function callMe(val) {
- console.log(val);
- }
-
- // Shorthand
- function checkReturn() {
- return test || callMe("test");
- }
- //Longhand
- function add(a, b) {
- return a + b;
- }
-
- //Shorthand
- const add = (a, b) => a + b;
更多示例。
- function callMe(name) {
- console.log("Hello", name);
- }
- callMe = (name) => console.log("Hello", name);
我们可以使用三元运算符来实现这些功能。
- // Longhand
- function test1() {
- console.log("test1");
- }
- function test2() {
- console.log("test2");
- }
- var test3 = 1;
- if (test3 == 1) {
- test1();
- } else {
- test2();
- }
-
- // Shorthand
- (test3 === 1 ? test1 : test2)();
我们可以将条件保存在键值对象中,并可以根据条件使用。
- // Longhand
- switch (data) {
- case 1:
- test1();
- break;
-
- case 2:
- test2();
- break;
-
- case 3:
- test();
- break;
- // And so on...
- }
-
- // Shorthand
- var data = {
- 1: test1,
- 2: test2,
- 3: test,
- };
-
- data[something] && data[something]();
使用箭头函数,我们可以直接返回值,而不必编写 return 语句。
- //longhand
- function calculate(diameter) {
- return Math.PI * diameter
- }
-
- //shorthand
- calculate = diameter => (
- Math.PI * diameter;
- )
- // Longhand
- for (var i = 0; i < 10000; i++) { ... }
-
- // Shorthand
- for (var i = 0; i < 1e4; i++) {
- //Longhand
- function add(test1, test2) {
- if (test1 === undefined) test1 = 1;
- if (test2 === undefined) test2 = 2;
- return test1 + test2;
- }
-
- //shorthand
- add = (test1 = 1, test2 = 2) => test1 + test2;
- add(); //output: 3
- //longhand
-
- // joining arrays using concat
- const data = [1, 2, 3];
- const test = [4, 5, 6].concat(data);
-
- //shorthand
-
- // joining arrays
- const data = [1, 2, 3];
- const test = [4, 5, 6, ...data];
- console.log(test); // [ 4, 5, 6, 1, 2, 3]
对于克隆,我们也可以使用扩展运算符。
- //longhand
-
- // cloning arrays
- const test1 = [1, 2, 3];
- const test2 = test1.slice();
-
- //shorthand
-
- // cloning arrays
- const test1 = [1, 2, 3];
- const test2 = [...test1];
如果您厌倦了在单个字符串中使用 + 来连接多个变量,那么这种简写可以消除您的头痛。
- //longhand
- const welcome = "Hi " + test1 + " " + test2 + ".";
-
- //shorthand
- const welcome = `Hi ${test1} ${test2}`;
当我们在代码中处理多行字符串时,可以使用以下功能:
- //longhand
- const data =
- "abc abc abc abc abc abc\n\t" +
- "test test,test test test test\n\t";
-
- //shorthand
- const data = `abc abc abc abc abc abc
- test test,test test test test`;
- let test1 = "a";
- let test2 = "b";
-
- //Longhand
- let obj = { test1: test1, test2: test2 };
-
- //Shorthand
- let obj = { test1, test2 };
- //Longhand
- let test1 = parseInt("123");
- let test2 = parseFloat("12.3");
-
- //Shorthand
- let test1 = +"123";
- let test2 = +"12.3";
- //longhand
- const test1 = this.data.test1;
- const test2 = this.data.test2;
- const test2 = this.data.test3;
-
- //shorthand
- const { test1, test2, test3 } = this.data;
当我们确实有一个对象数组并且我们想要根据对象属性查找特定对象时,find 方法确实很有用。
- const data = [
- {
- type: "test1",
- name: "abc",
- },
- {
- type: "test2",
- name: "cde",
- },
- {
- type: "test1",
- name: "fgh",
- },
- ];
- function findtest1(name) {
- for (let i = 0; i < data.length; ++i) {
- if (data[i].type === "test1" && data[i].name === name) {
- return data[i];
- }
- }
- }
-
- //Shorthand
- filteredData = data.find(
- (data) => data.type === "test1" && data.name === "fgh"
- );
- console.log(filteredData); // { type: 'test1', name: 'fgh' }
如果我们有代码来检查类型,根据类型需要调用不同的方法,我们可以选择使用多个 else ifs 或者 switch,但是如果我们有比这更好的简写方法呢?
- // Longhand
- if (type === "test1") {
- test1();
- } else if (type === "test2") {
- test2();
- } else if (type === "test3") {
- test3();
- } else if (type === "test4") {
- test4();
- } else {
- throw new Error("Invalid value " + type);
- }
-
- // Shorthand
- var types = {
- test1: test1,
- test2: test2,
- test3: test3,
- test4: test4,
- };
-
- var func = types[type];
- !func && throw new Error("Invalid value " + type);
- func();
当我们遍历数组以查找特定值时,我们确实使用 indexOf() 方法,如果找到更好的方法该怎么办?让我们看看这个例子。
- //longhand
- if (arr.indexOf(item) > -1) {
- // item found
- }
- if (arr.indexOf(item) === -1) {
- // item not found
- }
-
- //shorthand
- if (~arr.indexOf(item)) {
- // item found
- }
- if (!~arr.indexOf(item)) {
- // item not found
- }
按位(〜)运算符将返回除-1 以外的任何值的真实值。否定它就像做 ~~ 一样简单。另外,我们也可以使用 include() 函数:
- if (arr.includes(item)) {
- // true if the item found
- }
此函数有助于将对象转换为对象数组。
- const data = { test1: "abc", test2: "cde", test3: "efg" };
- const arr = Object.entries(data);
- console.log(arr);
- /** Output:
- [ [ 'test1', 'abc' ],
- [ 'test2', 'cde' ],
- [ 'test3', 'efg' ]
- ]
- **/
这也是 ES8 中引入的一项新功能,该功能执行与 Object.entries() 类似的功能,但没有关键部分:
- const data = { test1: "abc", test2: "cde" };
- const arr = Object.values(data);
- console.log(arr);
- /** Output:
- [ 'abc', 'cde']
- **/
双重 NOT 按位运算符方法仅适用于 32 位整数)
- // Longhand
- Math.floor(1.9) === 1; // true
-
- // Shorthand
- ~~1.9 === 1; // true
要一次又一次地重复相同的字符,我们可以使用 for 循环并将它们添加到同一循环中,但是如果我们有一个简写方法呢?
- //longhand
- let test = "";
- for (let i = 0; i < 5; i++) {
- test += "test ";
- }
- console.log(str); // test test test test test
-
- //shorthand
- "test ".repeat(5);
- const arr = [1, 2, 3];
- Math.max(…arr); // 3
- Math.min(…arr); // 1
- let str = 'abc';
-
- //Longhand
- str.charAt(2); // c
-
- //Shorthand
- Note: If we know the index of the array then we can directly use index insted of character.If we are not sure about index it can throw undefined
- str[2]; // c
- //longhand
- Math.pow(2, 3); // 8
-
- //shorthand
- 2 ** 3; // 8
原文作者:Atit
翻译:张张
在程序开发中,经常会使用到for循环的,但是很多人写的for循环效率都是比较低的,下面就举例说明,并总结优化for循环的方法,来提高我们程序的执行效率。
网站的加载速度不仅影响着用户体验,也会影响搜索引擎的排名,在百度推出“闪电算法”以来,将网站首屏打开速度被列入优化排名行列,作为前端开发的我们需要如果来优化网站的打开速度呢?下面就整理挖掘出很多细节上可以提升性能的东西分享给大家
DocumentFragments是DOM节点。它们不是主DOM树的一部分。通常的用例是创建文档片段,将元素附加到文档片段,然后将文档片段附加到DOM树。在DOM树中,文档片段被其所有的子元素所代替。因为文档片段存在于内存中,并不在DOM树中
对于代码裡面的 if else,我们可以使用逻辑判断式,或更好的三元判断式来优化代码。除了可以降低维护项目的成本之外,还可以提升代码可读性。就让我们从最简单的 if else 例子开始吧。
小程序从发布到现在也已经有将近两年的时间,越来越来多的公司开始重视小程序生态带来的流量,今年也由于小程序平台对外能力的越来越多的开放以及小程序平台的自身优化,越来越多的开发者也自主的投入到小程序的开发当中
无论你正在将 GIF 动图转换为 MP4 视频,还是手头已经有一大堆 MP4 视频,你都可以优化文件结构,以使得这些视频更快地加载和播放。通过重组 atoms 将 moov 放到文件开头,浏览器可以避免发送额外的 HTTP range request 请求来搜寻和定位 moovatom
要优化 Web 服务器的性能,我们先来看看 Web 服务器在 web 页面处理上的步骤:Web 浏览器向一个特定的服务器发出 Web 页面请求; Web 服务器接收到 web 页面请求后,寻找所请求的 web 页面,并将所请求的 Web 页面传送给 Web 浏览器; 显示出来
浏览器下载完页面所有的资源后,就要开始构建DOM树,于此同时还会构建渲染树(Render Tree)。(其实在构建渲染树之前,和DOM树同期会构建Style Tree。DOM树与Style Tree合并为渲染树)
写篇文章的目的,是以开放小程序代码的层面的优化。包括:条件判断将wx:if换成了hidden 、页面跳转请销毁之前使用的资源、列表的局部更新、小程序中多张图片懒加载方案、Input状态下隐藏input,应预留出键盘收起的时间
生活在信息爆炸的今天,我们每天不得不面对和过滤海量的信息--无疑是焦躁和浮动的,这就意味着用户对你站点投入的时间可能是及其吝啬的(当然有一些刚需站点除外)。如何给用户提供迅速的响应就显得十分重要了
内容以共享、参考、研究为目的,不存在任何商业目的。其版权属原作者所有,如有侵权或违规,请与小编联系!情况属实本人将予以删除!