>  기사  >  웹 프론트엔드  >  수집할 가치가 있는 JavaScript 사용 팁

수집할 가치가 있는 JavaScript 사용 팁

青灯夜游
青灯夜游앞으로
2019-11-29 15:25:412308검색

수집할 가치가 있는 JavaScript 사용 팁

모든 기술에는 실제로 사용할 수 있는 몇 가지 팁이 있습니다. 마찬가지로 JavaScript를 사용할 때 몇 가지 팁이 있지만 많은 경우 쉽게 간과될 수 있습니다. 인터넷에서는 업계의 많은 동료들이 때때로 이 분야에 대한 몇 가지 팁을 요약(또는 수집)합니다.

JavaScript 초보자라면 이러한 팁에 더 주의를 기울여야 합니다. 왜냐하면 이러한 팁은 실제 비즈니스 개발에서 문제를 해결하는 데 도움이 될 수 있고 쉽게 해결할 수 있기 때문입니다. 이번 글에서는 누구나 익숙하거나 익숙하지 않은 JavaScript에 관한 몇 가지 팁을 모아보겠습니다.

[관련 강좌 추천: JavaScript 동영상 튜토리얼]

Array

먼저 배열 사용에 관한 몇 가지 일반적인 팁을 살펴보겠습니다.

Array deduplication

ES6은 여러 가지 간결한 배열 중복 제거 방법을 제공하지만 이 방법은 기본 유형이 아닌 배열을 처리하는 데 적합하지 않습니다. 기본 유형 배열 중복 제거의 경우... new Set()을 사용하여 배열의 중복 값을 필터링하고 고유한 값만 포함하는 새 배열을 만들 수 있습니다.

const array = [1, 1, 2, 3, 5, 5, 1]
const uniqueArray = [...new Set(array)];
console.log(uniqueArray);

> Result:(4) [1, 2, 3, 5]

이것은 ES6의 새로운 기능입니다. ES6 이전에는 동일한 효과를 얻으려면 더 많은 코드를 사용해야 했습니다. 이 기술은 정의되지 않음, null, 부울, 문자열 및 숫자와 같은 기본 유형을 포함하는 배열에 작동합니다. 배열에 개체, 함수 또는 기타 배열이 포함되어 있으면 다른 방법을 사용해야 합니다.

위 방법 외에도 Array.from(new Set())을 사용하여 다음을 구현할 수도 있습니다.

const array = [1, 1, 2, 3, 5, 5, 1]
Array.from(new Set(array))

> Result:(4) [1, 2, 3, 5]

또한 Array의 .filter 및 indexOf()를 사용하여 다음을 구현할 수도 있습니다.

const array = [1, 1, 2, 3, 5, 5, 1]
array.filter((arr, index) => array.indexOf(arr) === index)

> Result:(4) [1, 2, 3, 5]

참고 indexOf() 메소드는 배열에서 배열 항목이 처음으로 나타나는 것을 반환합니다. 이것이 바로 indexOf() 메서드에서 반환된 인덱스를 각 반복마다 현재 인덱스와 비교하여 현재 항목이 중복인지 확인할 수 있는 이유입니다.

배열의 길이를 확인하세요

그리드 구조를 다룰 때 원본 데이터의 각 행의 길이가 같지 않으면 데이터를 다시 생성해야 합니다. 각 행의 데이터 길이가 동일하도록 하기 위해 Array.fill을 사용하여 다음을 처리할 수 있습니다.

let array = Array(5).fill('');
console.log(array);

> Result: (5) ["", "", "", "", ""]

Array mapping

Array.map을 사용하지 않고 배열 값을 매핑하는 방법입니다.

const array = [
    {
        name: '大漠',
        email: 'w3cplus@hotmail.com'
    },
    {
        name: 'Airen',
        email: 'airen@gmail.com'
    }
]
const name = Array.from(array, ({ name }) => name)

> Result: (2) ["大漠", "Airen"]

Array Truncation

배열 끝에서 값을 제거하려는 경우(배열의 마지막 항목 제거) splice()를 사용하는 것보다 더 빠른 대안이 있습니다.

예를 들어 원래 배열의 크기를 알고 있는 경우 배열의 길이 속성 값을 재정의하여 배열 끝의 값을 삭제할 수 있습니다.

let array = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
console.log(array.length)
> Result: 10

array.length = 4
console.log(array)
> Result: (4) [0, 1, 2, 3]

이것은 특히 깔끔한 솔루션입니다. 그러나 Slice() 메소드는 더 빠르게 실행되고 더 나은 성능을 제공합니다.

let array = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
array = array.slice(0, 4);

console.log(array); 
> Result: [0, 1, 2, 3]

Filter out falsy value in the array

배열에서 0과 같은 falsy 값을 필터링하려면, undefine, null, false, map 및 filter 메소드를 통해 달성할 수 있습니다:

const array = [0, 1, '0', '1', '大漠', 'w3cplus.com', undefined, true, false, null, 'undefined', 'null', NaN, 'NaN', '1' + 0]
array.map(item => {
    return item
}).filter(Boolean)

> Result: (10) [1, "0", "1", "大漠", "w3cplus.com", true, "undefined", "null", "NaN", "10"]

배열의 마지막 항목 가져오기

배열의 슬라이스() 값이 양수이면 다음 항목을 가로챕니다. 값이 음수인 경우 배열의 시작 부분부터 배열을 가져옵니다. 정수인 경우 배열의 끝 부분부터 배열 항목을 가져올 수 있습니다.

let array = [1, 2, 3, 4, 5, 6, 7]

const firstArrayVal = array.slice(0, 1)
> Result: [1]

const lastArrayVal = array.slice(-1)
> Result: [7]

console.log(array.slice(1))
> Result: (6) [2, 3, 4, 5, 6, 7]

console.log(array.slice(array.length))
> Result: []

위의 예에서 볼 수 있듯이 array.slice(-1)을 사용하여 배열의 마지막 항목을 가져옵니다. 또한 다음 방법을 사용하여 배열의 마지막 항목을 가져올 수도 있습니다.

console.log(array.slice(array.length - 1))
> Result: [7]

문자열 목록 필터링 및 정렬

많은 이름 목록이 있을 수 있으며 중복된 이름을 필터링하고 알파벳순으로 정렬해야 할 수 있습니다.

이 예에서는 다양한 언어 버전에 대한 JavaScript 예약어 목록을 준비했지만 보시다시피 중복 키워드가 많고 알파벳 순서로 정렬되지 않았습니다. 따라서 이것은 JavaScript 지식을 테스트하기 위한 완벽한 문자열(배열) 목록입니다.

var keywords = ['do', 'if', 'in', 'for', 'new', 'try', 'var', 'case', 'else', 'enum', 'null', 'this', 'true', 'void', 'with', 'break', 'catch', 'class', 'const', 'false', 'super', 'throw', 'while', 'delete', 'export', 'import', 'return', 'switch', 'typeof', 'default', 'extends', 'finally', 'continue', 'debugger', 'function', 'do', 'if', 'in', 'for', 'int', 'new', 'try', 'var', 'byte', 'case', 'char', 'else', 'enum', 'goto', 'long', 'null', 'this', 'true', 'void', 'with', 'break', 'catch', 'class', 'const', 'false', 'final', 'float', 'short', 'super', 'throw', 'while', 'delete', 'double', 'export', 'import', 'native', 'public', 'return', 'static', 'switch', 'throws', 'typeof', 'boolean', 'default', 'extends', 'finally', 'package', 'private', 'abstract', 'continue', 'debugger', 'function', 'volatile', 'interface', 'protected', 'transient', 'implements', 'instanceof', 'synchronized', 'do', 'if', 'in', 'for', 'let', 'new', 'try', 'var', 'case', 'else', 'enum', 'eval', 'null', 'this', 'true', 'void', 'with', 'break', 'catch', 'class', 'const', 'false', 'super', 'throw', 'while', 'yield', 'delete', 'export', 'import', 'public', 'return', 'static', 'switch', 'typeof', 'default', 'extends', 'finally', 'package', 'private', 'continue', 'debugger', 'function', 'arguments', 'interface', 'protected', 'implements', 'instanceof', 'do', 'if', 'in', 'for', 'let', 'new', 'try', 'var', 'case', 'else', 'enum', 'eval', 'null', 'this', 'true', 'void', 'with', 'await', 'break', 'catch', 'class', 'const', 'false', 'super', 'throw', 'while', 'yield', 'delete', 'export', 'import', 'public', 'return', 'static', 'switch', 'typeof', 'default', 'extends', 'finally', 'package', 'private', 'continue', 'debugger', 'function', 'arguments', 'interface', 'protected', 'implements', 'instanceof'];

원본 목록을 변경하고 싶지 않으므로 필터라는 고차 함수를 사용하겠습니다. 이 함수는 전달한 콜백 메서드를 기반으로 필터링된 새 배열을 반환합니다. 콜백 메소드는 원래 목록의 현재 키워드 색인을 새 목록의 색인과 비교하고 색인이 일치하는 경우에만 현재 키워드를 새 배열에 푸시합니다.

마지막으로 정렬 메서드를 사용하여 필터링된 목록을 정렬할 준비가 되었습니다. sort는 비교 메서드만 매개 변수로 허용하고 알파벳순으로 정렬된 목록을 반환합니다.

ES6에서는 화살표 함수 사용이 더 간단해 보입니다.

const filteredAndSortedKeywords = keywords
    .filter((keyword, index) => keywords.lastIndexOf(keyword) === index)
    .sort((a, b) => a < b ? -1 : 1);

다음은 JavaScript 예약어의 최종 필터링 및 정렬 목록입니다.

console.log(filteredAndSortedKeywords);

> Result: [&#39;abstract&#39;, &#39;arguments&#39;, &#39;await&#39;, &#39;boolean&#39;, &#39;break&#39;, &#39;byte&#39;, &#39;case&#39;, &#39;catch&#39;, &#39;char&#39;, &#39;class&#39;, &#39;const&#39;, &#39;continue&#39;, &#39;debugger&#39;, &#39;default&#39;, &#39;delete&#39;, &#39;do&#39;, &#39;double&#39;, &#39;else&#39;, &#39;enum&#39;, &#39;eval&#39;, &#39;export&#39;, &#39;extends&#39;, &#39;false&#39;, &#39;final&#39;, &#39;finally&#39;, &#39;float&#39;, &#39;for&#39;, &#39;function&#39;, &#39;goto&#39;, &#39;if&#39;, &#39;implements&#39;, &#39;import&#39;, &#39;in&#39;, &#39;instanceof&#39;, &#39;int&#39;, &#39;interface&#39;, &#39;let&#39;, &#39;long&#39;, &#39;native&#39;, &#39;new&#39;, &#39;null&#39;, &#39;package&#39;, &#39;private&#39;, &#39;protected&#39;, &#39;public&#39;, &#39;return&#39;, &#39;short&#39;, &#39;static&#39;, &#39;super&#39;, &#39;switch&#39;, &#39;synchronized&#39;, &#39;this&#39;, &#39;throw&#39;, &#39;throws&#39;, &#39;transient&#39;, &#39;true&#39;, &#39;try&#39;, &#39;typeof&#39;, &#39;var&#39;, &#39;void&#39;, &#39;volatile&#39;, &#39;while&#39;, &#39;with&#39;, &#39;yield&#39;]

배열 비우기

배열을 정의한 경우 비우고 싶을 때 . 일반적으로 다음과 같이 합니다.

let array = [1, 2, 3, 4];
function emptyArray() {
    array = [];
}
emptyArray();

그러나 배열을 지우는 더 효율적인 방법이 있습니다. 다음과 같이 쓸 수 있습니다:

let array = [1, 2, 3, 4];
function emptyArray() {
    array.length = 0;
}
emptyArray();

평면 다차원 배열

使用...运算符,将多维数组拍平:

const arr = [1, [2, &#39;大漠&#39;], 3, [&#39;blog&#39;, &#39;1&#39;, 2, 3]]
const flatArray = [].concat(...arr)
console.log(flatArray)

> Result: (8) [1, 2, "大漠", 3, "blog", "1", 2, 3]

不过上面的方法只适用于二维数组。不过通过递归调用,可以使用它适用于二维以下的数组:

function flattenArray(arr) {  
    const flattened = [].concat(...arr);  
    return flattened.some(item => Array.isArray(item)) ? flattenArray(flattened) : flattened;
}
const array = [1, [2, &#39;大漠&#39;], 3, [[&#39;blog&#39;, &#39;1&#39;], 2, 3]]
const flatArr = flattenArray(array)
console.log(flatArr)

> Result: (8) [1, 2, "大漠", 3, "blog", "1", 2, 3]

从数组中获取最大值和最小值

可以使用Math.max和Math.min取出数组中的最大小值和最小值:

const numbers = [15, 80, -9, 90, -99]
const maxInNumbers = Math.max.apply(Math, numbers)
const minInNumbers = Math.min.apply(Math, numbers)

console.log(maxInNumbers)
> Result: 90

console.log(minInNumbers)
> Result: -99

另外还可以使用ES6的...运算符来完成:

const numbers = [1, 2, 3, 4];
Math.max(...numbers) 
> Result: 4

Math.min(...numbers) 
> > Result: 1

对象

在操作对象时也有一些小技巧。

使用...运算符合并对象或数组中的对象

同样使用ES的...运算符可以替代人工操作,合并对象或者合并数组中的对象。

// 合并对象
const obj1 = {
    name: &#39;大漠&#39;,
    url: &#39;w3cplus.com&#39;
}
const obj2 = {
    name: &#39;airen&#39;,
    age: 30
}
const mergingObj = {...obj1, ...obj2}
> Result: {name: "airen", url: "w3cplus.com", age: 30}

// 合并数组中的对象
const array = [
    {
        name: &#39;大漠&#39;,
        email: &#39;w3cplus@gmail.com&#39;
    },
    {
        name: &#39;Airen&#39;,
        email: &#39;airen@gmail.com&#39;
    }
]
const result = array.reduce((accumulator, item) => {
    return {
        ...accumulator,
        [item.name]: item.email
    }
}, {})
> Result: {大漠: "w3cplus@gmail.com", Airen: "airen@gmail.com"}

有条件的添加对象属性

不再需要根据一个条件创建两个不同的对象,以使它具有特定的属性。为此,使用...操作符是最简单的。

const getUser = (emailIncluded) => {
    return {
        name: &#39;大漠&#39;,
        blog: &#39;w3cplus&#39;,
        ...emailIncluded && {email: &#39;w3cplus@hotmail.com&#39;}
    }
}

const user = getUser(true)
console.log(user)
> Result: {name: "大漠", blog: "w3cplus", email: "w3cplus@hotmail.com"}

const userWithoutEmail = getUser(false)
console.log(userWithoutEmail)
> Result: {name: "大漠", blog: "w3cplus"}

解构原始数据

你可以在使用数据的时候,把所有数据都放在一个对象中。同时想在这个数据对象中获取自己想要的数据。在这里可以使用ES6的Destructuring特性来实现。比如你想把下面这个obj中的数据分成两个部分:

const obj = {
    name: &#39;大漠&#39;,
    blog: &#39;w3cplus&#39;,
    email: &#39;w3cplus@hotmail.com&#39;,
    joined: &#39;2019-06-19&#39;,
    followers: 45
}
let user = {}, userDetails = {}

({name: user.name, email: user.email, ...userDetails} = obj)
> {name: "大漠", blog: "w3cplus", email: "w3cplus@hotmail.com", joined: "2019-06-19", followers: 45}

console.log(user)
> Result: {name: "大漠", email: "w3cplus@hotmail.com"}

console.log(userDetails)
> Result: {blog: "w3cplus", joined: "2019-06-19", followers: 45}

动态更改对象的key

在过去,我们首先必须声明一个对象,然后在需要动态属性名的情况下分配一个属性。在以前,这是不可能以声明的方式实现的。不过在ES6中,我们可以实现:

const dynamicKey = &#39;email&#39;
let obj = {
    name: &#39;大漠&#39;,
    blog: &#39;w3cplus&#39;,
    [dynamicKey]: &#39;w3cplus@hotmail.com&#39;
}

console.log(obj)
> Result: {name: "大漠", blog: "w3cplus", email: "w3cplus@hotmail.com"}

判断对象的数据类型

使用Object.prototype.toString配合闭包来实现对象数据类型的判断:

const isType = type => target => `[object ${type}]` === Object.prototype.toString.call(target)
const isArray = isType(&#39;Array&#39;)([1, 2, 3])

console.log(isArray)
> Result: true

上面的代码相当于:

function isType(type){
    return function (target) {
        return `[object ${type}]` === Object.prototype.toString.call(target)
    }
}

isType(&#39;Array&#39;)([1,2,3])
> Result: true

或者:

const isType = type => target => `[object ${type}]` === Object.prototype.toString.call(target)
const isString = isType(&#39;String&#39;)
const res = isString((&#39;1&#39;))

console.log(res)
> Result: true

检查某对象是否有某属性

当你需要检查某属性是否存在于一个对象,你可能会这样做:

var obj = {
    name: &#39;大漠&#39;
};
if (obj.name) { 
    console.log(true) // > Result: true
}

这是可以的,但是你需要知道有两种原生方法可以解决此类问题。in 操作符 和 Object.hasOwnProperty,任何继承自Object的对象都可以使用这两种方法。

var obj = {
    name: &#39;大漠&#39;
};
obj.hasOwnProperty(&#39;name&#39;);     // > true
&#39;name&#39; in obj;             // > true

obj.hasOwnProperty(&#39;valueOf&#39;);  // > false, valueOf 继承自原型链
&#39;valueOf&#39; in obj;          // > true

两者检查属性的深度不同,换言之hasOwnProperty只在本身有此属性时返回true,而in操作符不区分属性来自于本身或继承自原型链。

这是另一个例子:

var myFunc = function() {
    this.name = &#39;大漠&#39;;
};
myFunc.prototype.age = &#39;10 days&#39;;
var user = new myFunc();

user.hasOwnProperty(&#39;name&#39;); 
> Result: true

user.hasOwnProperty(&#39;age&#39;); 
> Result: false,   //  因为age来自于原型链

创造一个纯对象

使用Object.create(null)可以创建一个纯对象,它不会从Object类继承任何方法(例如:构造函数、toString() 等):

const pureObject = Object.create(null);

console.log(pureObject);                //=> {}
console.log(pureObject.constructor);    //=> undefined
console.log(pureObject.toString);       //=> undefined
console.log(pureObject.hasOwnProperty); //=> undefined

数据类型转换

JavaScript中数据类型有NumberStringBooleanObjectArrayFunction等,在实际使用时会碰到数据类型的转换。在转换数据类型时也有一些小技巧。

转换为布尔值

布尔值除了true和false之外,JavaScript还可以将所有其他值视为“真实的”或“虚假的”。除非另有定义,JavaScript中除了0、''、null、undefined、NaN和false之外的值都是真实的。

我们可以很容易地在真和假之间使用!运算符进行切换,它也会将类型转换为Boolean。比如:

const isTrue = !0;
const isFasle = !1;
const isFasle = !!0 // !0 => true,true的反即是false

console.log(isTrue)
> Result: true

console.log(typeof isTrue)
> Result: &#39;boolean&#39;

这种类型的转换在条件语句中非常方便,比如将!1当作false。

转换为字符串

我们可以使用运算符+后紧跟一组空的引号''快速地将数字或布尔值转为字符串:

const val = 1 + &#39;&#39;
const val2 = false + &#39;&#39;

console.log(val)
>  Result: "1"

console.log(typeof val)
> Result: "string"

console.log(val2)
> Result: "false"

console.log(typeof val2)
> Result: "string"

转换为数值

上面我们看到了,使用+紧跟一个空的字符串''就可以将数值转换为字符串。相反的,使用加法运算符+可以快速实现相反的效果。

let int = &#39;12&#39;
int = +int

console.log(int)
> Result: 12

console.log(typeof int)
> Result: &#39;number&#39;

用同样的方法可以将布尔值转换为数值:

console.log(+true)
> Return: 1

console.log(+false)
> Return: 0

在某些上下文中,+会被解释为连接操作符,而不是加法运算符。当这种情况发生时,希望返回一个整数,而不是浮点数,那么可以使用两个波浪号~~。双波浪号~~被称为按位不运算符,它和-n - 1等价。例如, ~15 = -16。这是因为- (-n - 1) - 1 = n + 1 - 1 = n。换句话说,~ - 16 = 15。

我们也可以使用~~将数字字符串转换成整数型:

const int = ~~&#39;15&#39;

console.log(int)
> Result: 15

console.log(typeof int)
> Result: &#39;number&#39;

同样的,NOT操作符也可以用于布尔值: ~true = -2~false = -1

浮点数转换为整数

平常都会使用Math.floor()Math.ceil()Math.round()将浮点数转换为整数。在JavaScript中还有一种更快的方法,即使用|(位或运算符)将浮点数截断为整数。

console.log(23.9 | 0);  
> Result: 23

console.log(-23.9 | 0); 
> Result: -23

|的行为取决于处理的是正数还是负数,所以最好只在确定的情况下使用这个快捷方式。

如果n是正数,则n | 0有效地向下舍入。如果n是负数,它有效地四舍五入。更准确的说,该操作删除小数点后的内容,将浮点数截断为整数。还可以使用~~来获得相同的舍入效果,如上所述,实际上任何位操作符都会强制浮点数为整数。这些特殊操作之所以有效,是因为一旦强制为整数,值就保持不变。

|还可以用于从整数的末尾删除任意数量的数字。这意味着我们不需要像下面这样来转换类型:

let str = "1553";

Number(str.substring(0, str.length - 1));
> Result: 155

我们可以像下面这样使用|运算符来替代:

console.log(1553 / 10   | 0)  
> Result: 155

console.log(1553 / 100  | 0)  
> Result: 15

console.log(1553 / 1000 | 0)  
> Result: 1

使用!!操作符转换布尔值

有时候我们需要对一个变量查检其是否存在或者检查值是否有一个有效值,如果存在就返回true值。为了做这样的验证,我们可以使用!!操作符来实现是非常的方便与简单。

对于变量可以使用!!variable做检测,只要变量的值为:0、null、" "、undefined或者NaN都将返回的是false,反之返回的是true。比如下面的示例:

function Account(cash) {
    this.cash = cash;
    this.hasMoney = !!cash;
}

var account = new Account(100.50);
console.log(account.cash); 
> Result: 100.50

console.log(account.hasMoney); 
> Result: true

var emptyAccount = new Account(0);
console.log(emptyAccount.cash); 
> Result: 0

console.log(emptyAccount.hasMoney); 
> Result: false

在这个示例中,只要account.cash的值大于0,那么account.hasMoney返回的值就是true。

还可以使用!!操作符将truthy或falsy值转换为布尔值:

!!""        // > false
!!0         // > false
!!null      // > false
!!undefined  // > false
!!NaN       // > false

!!"hello"   // > true
!!1         // > true
!!{}        // > true
!![]        // > true

小结

文章主要收集和整理了一些有关于JavaScript使用的小技巧。既然是技巧在必要的时候能帮助我们快速的解决一些问题。如果你有这方面的相关积累,欢迎在下面的评论中与我们一起分享。后续将会持续更新,希望对大家有所帮助。

本文来自 js教程 栏目,欢迎学习!

위 내용은 수집할 가치가 있는 JavaScript 사용 팁의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!

성명:
이 기사는 w3cplus.com에서 복제됩니다. 침해가 있는 경우 admin@php.cn으로 문의하시기 바랍니다. 삭제