Поскольку мяч круглый, все может случиться, я в этом уверен, но в последнее время я всегда задавался вопросом, что JavaScript тоже круглый!
Что такое «черный разговор»
Сленг, первоначально относился к кодовым словам и секретным кодам персонажей старых банд Цзянху, часто встречающимся в романах, а позже относится к языку, который популярен в особой отрасли и непонятен посторонним. «Сленговые слова», использованные в этой статье, на самом деле являются некоторыми необычными уловками, которые используют преимущества характеристик языка. Синтаксис JavaScript очень прост и гибок. Рекомендуется следовать спецификации ESLint, чтобы писать поддерживаемый код в проекте. ... Бессмертные из всех слоев общества также должны проявлять сдержанность. В конце концов, «сленговые слова» не всегда хороши. Если вы можете говорить о многих вещах напрямую, зачем вообще говорить об этом?
"арифметика"
Битовые операции в арифметике были занесены автором в список запрещенных, поэтому я надеюсь, что, когда вы используете битовые операции в своем проекте, убедитесь, что у вас есть веская причина для их использования, и при необходимости напишите комментарии Hack.
!и!!
!Это логический оператор НЕ, который можно применять к любому значению в ECMAScript, независимо от типа значения, оно будет преобразовано в логическую переменную, а его значение будет инвертировано.
!!Он просто выполняет два логических операции НЕ над операндами, которые могут преобразовывать любой тип значения в соответствующее логическое значение Шаги, которые он содержит:
- преобразовать значение в логическое значение;
- отрицать это;
- Снова отрицать.
Предположим, вам нужно использовать логическую переменную, чтобы указать, есть ли значение id, следующий метод написания рекомендует использовать последний метод для преобразования:
const enable1 = !!id；
const enable2 = id ? true : false;
const enable3 = Boolean(id);
~ и ~~
~означает побитовую инверсию,~5Шаги запуска:
- Преобразование в двоичное представление одного байта: 00000101,
- Побитовое отрицание: 11111010
- Возьмите его дополнение: 10000101
- Возьмем его дополнение: 10000110
- Преобразовать в десятичную: -6
~~Он означает оператор двойного, а не побитового отрицания, и если вы хотите использовать что-то более быстрое, чем Math.floor(), то это то, что вам нужно. Следует отметить, что для положительных чисел оно округляется в меньшую сторону, для отрицательных чисел округляется в большую сторону, нечисловые равны 0, и его конкретное выражение:
~~null; // => 0
~~undefined; // => 0
~~Infinity; // => 0
--NaN; // => 0
~~0; // => 0
~~{}; // => 0
~~[]; // => 0
~~(1/0); // => 0
~~false; // => 0
~~true; // => 1
~~1.9; // => 1
~~-1.9; // => -1
+
Первоначальная цель использования + перед значением переменной — преобразовать переменную в число, что особенно полезно, когда функция принимает параметр типа число:
+'1' // 1
+'-1' // '-1
+[] // 0
+{} // NaN
По наблюдениям,+aиa * 1Результаты были аналогичными. В дополнение к этому, использование + также может использоваться как немедленная функция:+function() {}(),равно(function(){})().
При добавлении строки и числа значение будет преобразовано в строку по умолчанию, поэтому существует сокращенный метод преобразования числа в строку:'' + 1.
& и &&
Если вы родом из C-подобного языка, пожалуйста, отбросьте предыдущий стереотип: & может действовать как логический оператор. В JavaScript & может выполнять только побитовые операции.
&, что означает побитовое И, этот оператор принимает два числа и возвращает число. Если они не являются числами, они преобразуются в числа. Если вы выполните7 & 3, он пройдет следующие этапы:
- Сначала конвертируйте в двоичный файл:
111 & 11 - Результат сравнения:
011 - Преобразование двоичного обратно в десятичное, поэтому:
7 & 3 = 3
Его также можно использовать для базового даже суждения:const isOdd = num => !!(num & 1);
&&, что означает логическое И, которое обычно используется для условного суждения if, но оно отличается от того, что вы себе представляли.&& не просто возвращает true или false, а на основе:
- Возвращает первое выражение, если первое выражение ложно;
- Возвращает второе выражение, если первое выражение истинно. Вот несколько примеров:
0 && false 0 (both are false-y, but 0 is the first)
true && false false (second one is false-y)
true && true true (both are true-y)
true && 20 20 (both are true-y)
&&Несколько операторов могут быть объединены, например:a && b && c && d, правила возврата значений такие же, как и выше. В дополнение к этому, он часто используется как логика короткого замыкания: если предыдущее выражение неверно, выполнение следующего выражения не будет продолжаться. Например, при взятии свойства объекта нам нужно судить, пусто ли оно, прежде чем принимать значение, иначе будет выброшено Uncaught TypeError, В этом случае мы также присвоим выражению значение по умолчанию через логическое ИЛИ:
const value = obj && obj.value || false
Когда вспомогательный инструмент сжатия JavaScript, если суждение, логика «Short-Circure» сохранит пространство памяти:
// before
if (test) { alert('hello') }
// after
test && alert('hello')
|с ||
они с&и&&Использование очень похоже, разница в том, что они представляют логическое ИЛИ, поэтому используйте|будет выполнять побитовую операцию ИЛИ, и||вернет первое истинное значение.
Использование || для присвоения значения по умолчанию очень распространено в JavaScript, который может опускать многие ненужные операторы if, такие как:
// before
let res;
if (a) {
res = a;
} else if (b) {
res = b;
} else if (c) {
res = c;
} else {
res = 1;
}
// after
const res = a || b || c || 1;
== и ===
==Для оператора равенства оператор сначала преобразует левый и правый операнды в один и тот же операнд, а затем выполняет сравнение на равенство.
===Это оператор равенства, за исключением того, что он не приводит операнды во время сравнения, а остальные суждения равенства такие же, как и==Последовательный.
Проще говоря,==Используется для определения того, равны ли значения,===Оценивая, равны ли значение и тип, более точно использовать оператор сравнения для оценки операндов Первые несколько советов, полученных новичками, которые также изучают JavaScript, — избегать использования оператора равенства, это правда? Да, это гарантирует, что вы сможете максимально избежать ошибок, если вы не очень хорошо знакомы с языком, но мы также должны четко понимать, в каких ситуациях вы должны использовать оператор равенства.Правила часто только для новичков, но для умный ты Самое главное знать, что ты делаешь.
Оператор равенства сравнивает значения разных типов, как показано на следующем рисунке:
| B | |||||||
|---|---|---|---|---|---|---|---|
| Undefined | Null | Number | String | Boolean | Object | ||
| A | Undefined | true |
true |
false |
false |
false |
IsFalsy(B) |
| Null | true |
true |
false |
false |
false |
IsFalsy(B) |
|
| Number | false |
false |
A === B |
A === ToNumber(B) |
A=== ToNumber(B) |
A=== ToPrimitive(B) |
|
| String | false |
false |
ToNumber(A) === B |
A === B |
ToNumber(A) === ToNumber(B) |
ToPrimitive(B) == A |
|
| Boolean | false |
false |
ToNumber(A) === B |
ToNumber(A) === ToNumber(B) |
A === B |
ToNumber(A) == ToPrimitive(B) |
|
| Object | false |
false |
ToPrimitive(A) == B |
ToPrimitive(A) == B |
ToPrimitive(A) == ToNumber(B) |
A === B
|
|
Для неопределенного и нулевого:undefined равно null, но не равно любому другому объекту, поэтому в некоторых библиотеках вы можете увидеть следующее:
if (VAR == undefined) {}
if (VAR == null) {}
Это эквивалентно:
if (VAR === undefined || VAR === null) {}
за'', false, 0, все они принадлежатFalsyтипа, через логические объекты преобразуются в ложные значения, а через==Судя по соотношению между тремя, они всегда равны, потому что при сравнении значений все они будут преобразованы в ложные значения из-за разных типов:
console.log((false == 0) && (0 == '') && ('' == false)) // true
Или иногда мы хотим использовать функцию приведения для сравнения строк и чисел:
console.log(11 == '11') // true
console.log(11 === '11') // false
^
Побитовый оператор XOR сравнивает каждый бит и возвращает 1, если биты не совпадают, иначе возвращает 0. Мало кто использует этот оператор в веб-разработке, за исключением одного легендарного сценария: подкачки значений.
Чтобы поменять местами значения a и b, рекомендуется использовать:
[a, b] = [b, a];
Или создайте новый c для хранения временных переменных, если вы столкнетесь с тем, что кто-то пишет это:
// 异或运算，相同位取0，不同位取1，a ^ b ^ b = a， a ^ a ^ b = b
a = a ^ b
b = a ^ b
a = a ^ b
Этот способ обмена двумя числовыми переменными через операцию XOR, пожалуйста, простите его и игнорируйте, он может быть только новичком, который одержим магией, и желаю ему скорейшего открытия, что лаконичные и легко читаемые функции являются лучшей практикой.
..
В JavaScipt как целые числа, так и числа с плавающей запятой принадлежатNumberтип, все числа хранятся как 64-битные числа с плавающей запятой, поэтому за числами может следовать десятичная точка при синтаксическом анализе операторов (1. === 1), но это на самом деле вызовет проблему, интерпретатор не сможет разобрать1.toString()Такой оператор выдаст:Uncaught SyntaxError, то в выражении.не рассматривается как средство доступа к свойству, а комбинируется с 1 как число с плавающей запятой1., поэтому программа сообщит об ошибке,1.toString()Эквивалентно1toString().
Чтобы было легче понять, запомните это правило: в глазах интерпретатора первое вхождение выражения типа Число.десятичный разделитель для чисел с плавающей запятой, второй.для средств доступа к свойствам. Например1.0.toString()и1..toString()Этот синтаксис работает нормально. Следует отметить, что разница между переменной и выражением, если переменной присвоено числовое выражение, метод прототипа может быть вызван непосредственно через переменную, потому что в это время.Нет никакой двусмысленности.
Такая нечетко типизированная структура действительно вводит в заблуждение, и всем нам следует избегать таких двусмысленных выражений в программах и использовать круглые скобки для устранения неоднозначности числовых выражений.(1).toString(), не для крутого использования1..toString().
void
Согласно определению в MDN:void对给定的表达式进行求值，然后返回undefined, мы можем понять это предложение по-разному.
Во-первых, его можно использовать вместо undefined, так как undefined не является зарезервированным словом, а на самом деле является значением глобальной переменной, поэтому мы можем изменить его, и программа может оказаться нестабильной, она уже доступна только для чтения. property в ES5., но в локальном масштабе все равно можно перегружаться (у вас тоже может быть паранойя жертвы):
(function() {
const undefined = 'hello';
console.log(undefined); // hello
})();
Во-вторых, мы можем добавить перед функцией ключевое слово void, указывающее, что функция не имеет возвращаемого значения, но нет необходимости добавлять его в каждую функцию, что не соответствует стилю кода JavaScript. мы можем использовать его для выполнения IIFE (функция немедленного выполнения), давайте посмотрим на следующий пример:
const arrs = []
(function() {
console.log('hello')
})()
Если вы не привыкли писать точки с запятой, очень вероятно, что вы сталкивались с ошибкой такого рода:Uncaught TypeError: [] is not a function, это связано с тем, что редактор не может выполнить правильную сегментацию слов при выполнении minify.В настоящее время такие проблемы можно решить через void, который решает проблему сегментации слов и делает более элегантным непосредственное выполнение вызовов функций:
const arrs = []
void function() {
console.log('hello')
}()
Иногда мы не хотим, чтобы метка перескакивала, вот несколько распространенных способов:
<!-- 使用preventDefault -->
<a id="a" href="">hello</a>
<script>
a.addEventListener('click', e => e.preventDefault());
</script>
<!-- 使用return false -->
<a href="" onclick="return false;">hello</a>
Когда мы устанавливаем значение href какundefined, что также позволяет избежать поведения перехода по умолчанию для тега a:
<a href="javascript: void 0;" onclick="return false;">hello</a>
>>> 0
Операция беззнакового сдвига вправо не выполняет специальной обработки знакового бита старшего бита, перемещает весь двоичный код вправо, отбрасывает младший бит и дополняет старший бит 0. Возьмем 1-байтовое целое число в качестве пример:
-
3 >>> 1Эквивалентно0000 0011Сдвиг на 1 бит вправо:000 0001, а затем добавьте 0 к старшему биту:0000 0001,Сейчас3 >>> 1 = 1
В js всегда можно найти применение>>> 0Основная особенность кода Hack заключается в том, что беззнаковый сдвиг вправо на 0 бит может преобразовывать все типы значений в числовые типы для унифицированной обработки, а нечисловые типы преобразуются в 0. Некоторые основные способы использования перечислены ниже:
| тип | действовать | Пример |
|---|---|---|
| положительное число | ничего не делать | 1 >>> 0 = 1 |
| отрицательное целое число | Возьмите значение отрицательного дополнения | -1 >>> 0 = 4294967295 |
| Логическое значение | Преобразовать в 1 или 0 |
true >>> 0 = 1,false >>> 0 = 0
|
| нить | Если isNaN(str), значение равно 0, в противном случае значение равноparseInt(str) >>> 0
|
'1' >>> 0 = 1,'s' >>> 0 = 0
|
| число с плавающей запятой | Отбросьте десятичные разряды перед выполнением целочисленной операции сдвига |
1.1 >>> 0 = 1 >>> 0,-1.1 >>> 0 = -1 >>> 0
|
| другие объекты | Универсальное значение равно 0 |
[] >>> 0 = 0,undefined >>> 0 = 0,... |
Числовое представление
3e9
Научная нотация — это математический термин, выражающий число, умноженное на 10 в n-й степени.Например, скорость света составляет 300 000 километров в секунду.В расчетах в качестве единицы обычно используется метр, и ее записывают как: 300000000 м/с, а в JavaScript мы можем использовать научную запись3e9Выражать.
Примеры нескольких научных отсчетов:
1e5; // 100000
2e-4; // 0.0002
-3e3; // -3000
Числовые объекты имеютtoExponential(fractionDigits)Метод возвращает строковое представление значения в экспоненциальном представлении.Параметр FractionDigits является необязательным и используется для указания количества цифр после запятой, например:(179000).toExponential(); // "1.79e+5".
JavaScript автоматически преобразует числа в экспоненциальное представление в следующих случаях:
- Перед запятой более 21 цифры.
- Значение меньше 1 и после запятой более 5 нулей, например
0.0000001.
.5px
Обычно некоторые люди привыкли опускать числа, начинающиеся с 0. Это часто используется в числовых вычислениях и свойствах css, таких как0.5pxможно записать прямо как.5px,0.2 * 0.3можно записать как:.2 * .3
0x, 0o и 0b
После долгого пребывания в десятичном мире, пожалуйста, не забывайте, что есть и другие основания, и они имеют такой же статус в компьютере. JavaScript предоставляет следующие базовые представления:
- Двоичный: используйте только два числа 0 и 1 с префиксом
0b, десятичное число 13 может быть выражено как0b1101 - Восьмеричный: используйте только восемь цифр от 0 до 7 с префиксом
0o、0, десятичное число 13 может быть выражено как0o15、015 - Шестнадцатеричный: используйте только десять цифр от 0 до 9 и шесть букв от a до f с префиксом
0x, десятичное число 13 может быть выражено как0xd
По умолчанию JavaScript автоматически преобразует восьмеричные, шестнадцатеричные и двоичные числа в десятичные перед выполнением операций. Чтобы преобразовать десятичную систему счисления в другие базы, см.toStringметод, чтобы преобразовать из других оснований в десятичные, пожалуйста, обратитесь кparseIntметод, из других оснований в другие, сначала преобразуйте в десятичный, а затем в другие методы.
"Говорить"
Array.prototype.sort
Array.prototype.sort() по умолчанию сортирует строку в соответствии с кодировкой Unicode. Конкретный алгоритм зависит от реализованного браузера.двигатель v8, если длина массива меньше 10, используется сортировка вставками, а если длина больше 10, используется быстрая сортировка.
А sort поддерживает передачуcompareFunction(a, b)Параметры , где a и b — два непустых объекта для сравнения в массиве (все пустые объекты будут ранжированы в конце массива) Конкретные правила сравнения:
- Возвращаемое значение меньше 0, а a расположено слева от b
- Возвращаемое значение равно 0, а позиции a и b неизменны.
- Возвращаемое значение больше 0, а a расположено справа от b
Поэтому используйте sort, чтобы написать метод для перемешивания массива:
[1,2,3,4].sort(() => .5 - Math.random())
Однако приведенная выше реализация не является полностью случайной, поскольку некоторые элементы не имеют возможности сравниваться из-за нестабильности алгоритма сортировки.проблема, для достижения полной случайности в лотерейной программе используйтеПеретасовка Фишера – ЙейтсаАлгоритм следующей простой реализации:
function shuffle(arrs) {
for (let i = arrs.length - 1; i > 0; i -= 1) {
const random = Math.floor(Math.random() * (i + 1));
[arrs[random], arrs[i]] = [arrs[i], arrs[random]];
}
}
Array.prototype.concat.apply
apply принимает аргумент типа array для вызова функции, тогда как concat принимает несколько аргументов в виде строки или массива, поэтому вы можете использовать этот трюк, чтобы напрямую сгладить двумерный массив:
Array.prototype.concat.apply([], [1, [2,3], [4]])
И с помощью этого метода вы также можете написать метод глубокого обхода:
function flattenDeep(arrs) {
let result = Array.prototype.concat.apply([], arrs);
while (result.some(item => item instanceof Array)) {
result = Array.prototype.concat.apply([], result);
}
return result;
}
После тестирования эффективность сравнивается с lodash следующим образом:
в вышеуказанном методеArray.prototype.concat.apply([], target)Это также может быть записано как:[].concat(...target).
Array.prototype.push.apply
В es5, если мы хотим объединить массивы, мы привыкли использовать метод concat в массивах:
let arrs = [1, 2, 3];
arrs = arrs.concat([4,5,6]);
Но есть также классный способ использовать функцию параметра массива метода apply для более лаконичного выполнения операции сплайсинга:
const arrs = [1, 2, 3];
arrs.push.apply(arrs, [4, 5, 6]);
Array.prototype.length
Обычно он используется для возврата длины массива, но это также свойство со сложным поведением, первое, что нужно отметить, это то, чтоОн не используется для подсчета количества элементов в массиве., но представляет значение с наивысшим индексом в массиве:
const arrs = [];
arrs[5] = 1;
console.log(arrs.length); // 6
Кроме того, длина length изменяется при изменении массива, но это изменение ограничено:Изменение максимального значения индекса дочернего элемента, если использоватьdeleteМетод удаляет самый старший элемент, а длина не изменится, потому что самое высокое значение индекса не изменилось:
const arrs = [1, 2, 3];
delete arrs[2]; // 长度依然为3
Еще одной важной особенностью длины является то, что она позволяет изменять ее значение, если измененное значение меньше максимального индекса самого массива, массив будет частично перехвачен:
const arrs = [1, 2, 3, 4];
arrs.length = 2; // arrs = [1, 2]
arrs.length = 0; // arrs = []
Если вы присвоите значение больше, чем текущий максимальный индекс, вы получите разреженный массив:
const arrs = [1, 2];
arrs.length = 5; // arrs = [1, 2,,,,]
Если значение равно 0, выполнениепустой массивоперация:
const arrs = [1, 2, 3, 4];
arrs.length = 0; // arrs = []
Использование этого метода удалит все индексы в массиве, поэтому он также повлияет на другие значения, ссылающиеся на этот массив, что аналогично использованиюarrs = []Существует большая разница:
let a = [1,2,3];
let b = [1,2,3];
let a1 = a;
let b1 = b;
a = [];
b.length = 0;
console.log(a, b, a1, b1); // [], [], [1, 2, 3], []
При изменении длины также необходимо обратить внимание:
- Значение должно быть положительным целым числом.
- Передача строки попытается преобразовать ее в числовой тип.
Object.prototype.toString.call
У каждого объекта есть метод toString(), который автоматически вызывается, когда на объект ссылаются как на строку.Если этот метод не переопределен, toString вернет [тип объекта], поэтомуObject.prototype.toString.callПросто чтобы вызвать непереопределенный метод для собственного объекта, call укажет область действия на оцениваемый объект, так что строка типа объекта может быть напечатана с помощью собственного метода toString:Object.prototype.toString.call([]) => "[object Array]", используя эту функцию, оценка типа может быть реализована более точно.
В ES3 полученный тип является атрибутом внутреннего атрибута [[Class]], по которому можно определить, какому встроенному значению принадлежит нативный атрибут; в ES5 добавлено два новых правила: если это значение равно null, undefined возвращает: [object Null], [object Undefined]; [[Class]] не существует в ES6 и заменяется внутренним свойством: [[NativeBrand]], которое является значением тега, используемым для различения свойств нативного объект, конкретные правила суждения таковы:
19.1.3.6Object.prototype.toString ( )
When the toString method is called, the following steps are taken:
If the this value is undefined, return "[object Undefined]".
If the this value is null, return "[object Null]".
Let O be ! ToObject(this value).
Let isArray be ? IsArray(O).
If isArray is true, let builtinTag be "Array".
Else if O is a String exotic object, let builtinTag be "String".
Else if O has a [[ParameterMap]] internal slot, let builtinTag be "Arguments".
Else if O has a [[Call]] internal method, let builtinTag be "Function".
Else if O has an [[ErrorData]] internal slot, let builtinTag be "Error".
Else if O has a [[BooleanData]] internal slot, let builtinTag be "Boolean".
Else if O has a [[NumberData]] internal slot, let builtinTag be "Number".
Else if O has a [[DateValue]] internal slot, let builtinTag be "Date".
Else if O has a [[RegExpMatcher]] internal slot, let builtinTag be "RegExp".
Else, let builtinTag be "Object".
Let tag be ? Get(O, @@toStringTag).
If Type(tag) is not String, set tag to builtinTag.
Return the string-concatenation of "[object ", tag, and "]".
This function is the %ObjProto_toString% intrinsic object.
NOTE
Historically, this function was occasionally used to access the String value of the [[Class]] internal slot that was used in previous editions of this specification as a nominal type tag for various built-in objects. The above definition of toString preserves compatibility for legacy code that uses toString as a test for those specific kinds of built-in objects. It does not provide a reliable type testing mechanism for other kinds of built-in or program defined objects. In addition, programs can use @@toStringTag in ways that will invalidate the reliability of such legacy type tests.
Object.create(null)
Используется для создания объектов без «побочных эффектов», т. е. создаетпустой объект, исключая цепочку прототипов и другие свойства. При использованииconst map = {}Созданный объект эквивалентен Object.create(Object.prototype), который наследует цепочку прототипов объекта.
JSON.parse(JSON.stringify(Obj))
Очень распространенный метод глубокого копирования объектов, форматирование объекта как строки JSON, а затем его анализ для получения нового объекта.Следует отметить, что его производительность не особенно высока, и он не может обрабатывать ссылки с обратной связью, такие как:
const obj = {a: 1};
obj.b = obj;
JSON.parse(JSON.stringify(obj)) // Uncaught TypeError: Converting circular structure to JSON
Таким образом, производительность синтаксического анализа JSON невысока. Если объект может быть скопирован с помощью неглубокого копирования, используйте метод поверхностного копирования, независимо от того, что вы используете.{...obj}все ещеObject.assign({}, obj)образом, и если есть требования к производительности, пожалуйста, не изобретайте велосипед, просто используйте пакет npm:clone или что-то еще.
генерировать [0, 1, ..., N-1]
Я смутно помню, насколько лаконичен синтаксис для генерации списков в Python:[ x for x in range(1, 10) ], то как инициализировать упорядоченную последовательность от 1 до 10 в JavaScript?
Есть правила вождения, используйте напрямуюnew Array(10)инициализировать и.mapнежелательно, потому что это устанавливает только поле длины массива:
Object.getOwnPropertyNames([1, 2, 3]) // ["0", "1", "2", "length"]
const a = new Array(3) // [undefined, undefined, undefined]
Object.getOwnPropertyNames(a) // ["length"]
Это приведет кmap,filterи т. д. Итерационные методы недопустимы, конечно, используйтеfillПосле заполнения элементами массива можно манипулировать как обычно, но здесь будут использоваться другие методы.
В прошлом людям нравилось использовать этот хак для инициализации массивов фиксированной длины:Array.apply(null, { length: 3 }), Следует отметить, что,{ length: 3 }По сути, это массивоподобный объект, внутренние параметры Array.prototype.apply могут быть реализованы так:
for (let index = 0; i < arguments[1].length; index++) {
// pass arguments[1][index]
}
Из-за этого, если у вас нет проблем с основами, вы обнаружите, что приведенное выше утверждение на самом деле эквивалентно:Array(undefined, undefined, undefined), чтобы подвести итог, оператор последовательности, который генерирует 0 ~ 10, может быть записан как:
Array.apply(null, { length: 10 }).map((v, k) => k)
А для ES6 его вполне можно использоватьArray.fromВместо приведенного выше утверждения:
Array.from(new Array(10), (k, v) => v)
Array.fromВ качестве параметров принимаются не только строки, наборы, карты и массивоподобные объекты, но и любой итерируемый объект, например, мы используем генераторы для развлекательных целей:
function* range(start, end) {
for (let i = start; i < end; i++) {
yield i
}
}
Array.from(range(1, 10)) // [1, 2, 3, 4, 5, 6, 7, 8, 9]
[...range(1, 10)] // [1, 2, 3, 4, 5, 6, 7, 8, 9]
"теория"
Правда и ложь
Для каждого типа значения каждый объект имеет логическое значение. Falsy представляет значение, которое является ложным в логическом объекте. При условном суждении и зацикливании JavaScript принудительно превращает любой тип в логический объект. Все следующие объекты ведут себя как Falsy, когда встречаются с оператором if:
if (false)
if (null)
if (undefined)
if (0)
if (NaN)
if ('')
if ("")
if (document.all)
document.all относится к историческим причинам, поэтому он ложный, он нарушает спецификацию JavaScript, вы можете его игнорировать, а переменную NaN, не судите о ней по конгруэнтности или равенству, потому что она начинает сходить с ума и даже поражает сама себя:
console.log(NaN === 0) // false
console.log(NaN === NaN) // false
console.log(NaN == NaN) // false
Но мы можем использовать метод Object.is, чтобы определить, является ли значение NaN.Это новый синтаксис, добавленный ES6 для сравнения того, совпадают ли два значения.Его можно рассматривать как более строгий метод суждения, чем тестер конгруэнтности. , но это не может быть Mix it Up:
Object.is(NaN, NaN) // true
Object.is(+0, -0) // false
Помимо значений Falsy, все значения являются значениями Truthy, которые являются истинными в логическом контексте.
разное
Вышеприведенное в основном обобщает некоторые приемы и приемы, с которыми я столкнулся в JavaScript, но стоит углубиться лишь в некоторые точки знаний. Мы должны уделять больше внимания принципам, а не синтаксису, чтобы адаптироваться к постоянные изменения.