Partagez une syntaxe ou des techniques cachées peu connues en JavaScript

javaScript est souvent considéré comme le langage le plus simple pour démarrer et le plus difficile à maîtriser, et je ne pourrais être plus d'accord. En effet, JavaScript est un langage très ancien et très flexible avec une syntaxe obscure et des fonctionnalités obsolètes.

J'utilise JavaScript depuis de nombreuses années et jusqu'à présent, je trouve occasionnellement une syntaxe cachée ou des astuces dont j'ignorais l'existence. Même si ces propriétés sont moins connues, elles n’en sont pas moins bien connues.

Remarque : la promotion de variables, les fermetures, les proxys, l'héritage prototypique, l'attente asynchrone, les générateurs, etc. ne sont pas inclus ici.

opérateur void

JavaScript a un opérateur void unaire. Vous l'avez peut-être vu utilisé comme void(0) ou void 0. La fonction de void est de renvoyer undéfini. L'opérande à droite sera calculé normalement, mais quel que soit le résultat, void renverra undéfini. Utiliser "0" n'est qu'une convention. Il n'est pas nécessaire d'utiliser '0', il peut s'agir de n'importe quelle expression valide, comme void , elle renverra toujours undéfini.

// void operator
void 0                  // returns undefined
void (0)                // returns undefined
void 'abc'              // returns undefined
void {}                 // returns undefined
void (1 === 1)          // returns undefined
void (1 !== 1)          // returns undefined
void anyfunction()      // returns undefined

Pourquoi créer un mot-clé spécial pour renvoyer undéfini au lieu de simplement renvoyer undéfini ? Cela semble un peu redondant, n'est-ce pas ?

Faits amusants

En fait, avant ES5, dans la plupart des navigateurs, l'original undefined = "abc" pouvait se voir attribuer une nouvelle valeur. Ainsi, à cette époque, utiliser void était un moyen de garantir que la valeur originale de undefined était toujours renvoyée.

Les crochets du constructeur sont facultatifs

Oui, les crochets que nous ajoutons après le nom de la classe lors de l'appel du constructeur - complètement facultatifs (à condition qu'il ne soit pas nécessaire de transmettre des paramètres au constructeur ! )

Les deux styles de codage suivants sont considérés comme une syntaxe JS valide et les résultats sont les mêmes !

// Constructor with brackets
const date = new Date()
const month = new Date().getMonth()
const myInstance = new MyClass()

// Constructor without brackets
const date = new Date
const month = (new Date).getMonth()
const myInstance = new MyClass

Oui Omettre les parenthèses pour IIFE (fonction immédiatement invoquée)

La syntaxe de l'IIFE (expression de fonction immédiatement invoquée) m'a toujours été un peu étrange, pourquoi y a-t-il autant de parenthèses ?

En fait, ces crochets supplémentaires servent simplement à indiquer à l'analyseur JavaScript que le code à analyser est une expression de fonction, pas une fonction. Sachant cela, vous pouvez imaginer qu'il existe de nombreuses façons d'omettre ces parenthèses supplémentaires tout en travaillant efficacement avec IIFE. L'opérateur

// IIFE

(function () {
  console.log('正常形式的 IIFE 调用')
})()

// 清爽的 IIEF 
void function() {
  console.log('酷酷的 IIFE 调用')
}()

void indique à l'analyseur que le code est une expression de fonction. Par conséquent, nous pouvons ignorer les parenthèses autour de la définition de la fonction. Devinez quoi ? Nous pouvons utiliser n'importe quel opérateur unaire (void， +， !， -等等) et cela fonctionne toujours

N'est-ce pas plus simple et plus B-carré que la méthode originale ?

Mais si vous êtes un observateur attentif, vous vous demandez peut-être : les opérateurs unaires n'affectent-ils pas le résultat renvoyé par IIFE ?

Cela affectera les résultats. Mais la bonne nouvelle est que si vous renvoyez simplement le résultat et le stockez dans une variable, vous n'avez pas besoin de parenthèses supplémentaires.

Déclaration de with

JavaScript a un bloc d'instruction with, et with est en fait un mot-clé en JS. La syntaxe du bloc with est la suivante :

L'instruction with peut être facilement utilisée pour référencer des propriétés existantes dans un objet spécifique, mais elle ne peut pas être utilisée pour ajouter des propriétés à l'objet. Pour créer de nouvelles propriétés sur un objet, vous devez explicitement référencer l'objet.

Fun Facts

avec des blocs, ça a l'air cool, non ? C'est encore mieux que la destruction d'objets. Eh bien, pas vraiment.

L'utilisation de l'instruction with est généralement déconseillée car elle est obsolète et totalement interdite en mode strict. Il s'avère que l'utilisation de blocs with augmente certains problèmes de performances et de sécurité dans le langage.

Constructeur de fonctions

Les instructions de fonction ne sont pas le seul moyen de définir de nouvelles fonctions. Les fonctions peuvent être définies dynamiquement à l'aide du constructeur function() et de l'opérateur new.

Faits intéressants

Le constructeur de fonctions est la mère de tous les constructeurs en JavaScript. Même le constructeur d'Object est un constructeur de Fonction. Et le propre constructeur de Function est également Function lui-même.

Ainsi, appeler object.constructor.constructor... suffisamment de fois finira par renvoyer le constructeur Function sur n'importe quel objet en JavaScript.

函数属性

我们都知道函数是JavaScript中的第一类对象。因此，没有人阻止我们向函数添加自定义属性。在 JS 中这样做是有效的，然而，它很少被使用。

那么我们什么时候要这样做?

这里有一些很好的用例。例如,

可配置函数

假设我们有一个函数叫做 greet。我们希望函数根据不同的地区打印不同的问候消息，这个区域设置也应该是可配置的。我们可以在某个地方维护全局 locale 变量，也可以使用如下所示的函数属性实现该函数

function greet () {
  if (greet.locale === 'ch') {
    console.log('中国，你好')
  } else if (greet.locale === 'jp') {
    console.log('扣你机哇!')
  } else {
    console.log('Hello World')
  }
}

greet() // Hello World
greet.locale = 'ch';
greet() // 中国，你好

具有静态变量的函数

另一个类似的例子。比方说，希望实现一个生成有序数字序列的数字生成器。通常您将使用带有静态计数器变量的 Class 或 IIFE 来跟踪最后一个值。这样我们就限制了对计数器的访问，同时也避免了使用额外的变量污染全局空间。

但是，如果我们希望能够灵活地读取甚至修改计数器，而又不污染全局空间，该怎么办呢?

我们仍然可以创建一个类，有一个计数器变量和一些额外的方法来读取它;或者我们可以偷懒，使用函数自定义的属性。

Arguments 的属性

我相信你们大多数人都知道函数中的arguments对象。它是一个类似数组的对象，可以在所有函数中使用。它具有在调用函数时传递给函数的参数列表。但它也有一些其他有趣的性质：

• arguments.callee： 当前调用的函数

• arguments.callee.caller：调用当前函数的函数

注意:虽然ES5禁止在严格模式下使用callee & caller，但在许多编译后的库中仍然很常见。所以，学习它们是值得的。

标记模板字符串

模板字符串文字是ES6中许多很酷的附加内容之一，但是，知道标记模板字符串是比较少的?

标记模板字符串允许你通过向模板字符串添加自定义标记来更好地将模板文字解析为字符串。Tag只是一个解析器函数，它获取字符串模板解释的所有字符串和值的数组，标记函数应返回最终字符串。

在下面的例子中，我们的自定义标记 —— 高亮显示，解释模板文本的值，并将解释后的值包装在结果字符串中，使用元素进行高亮显示。

Getters & Setters

在大多数情况下，JavaScript对象是简单的。假设我们有一个 user 对象，我们试图使用user访问它的age属性。使用 user.age 得到年龄属性的值，如果没有定义，我们得到未定义的值。

但是，并不一定要这么简单。JavaScript 对象具有 getter 和 setter 的概念。我们可以编写自定义Getter函数来返回我们想要的任何东西，而不是直接返回对象上的值，设置一个值也是一样。

这使我们可以在获取或设置字段时拥有强大的能力，如 virtual fields，field validations，side-effects。

逗号操作符

JavaScript有一个逗号操作符。它允许我们在一行中用逗号分隔多个表达式，并返回上一个表达式的结果。

在这里，所有表达式都将被求值，结果变量将被赋值给expressionN返回的值。

我们经常在for循环中使用了逗号操作符

for (var a = 0, b = 10; a <= 10; a++, b--)

有时在一行中编写多个语句

function getNextValue() {    return counter++, console.log(counter), counter
}

或者

const getSquare = x => (console.log (x), x * x)

+ 加号操作符号

想要快速地将字符串转换为数字吗?

只需在字符串前面加上+运算符。加号运算符也适用于负数、八进制、十六进制、指数值。更重要的是，它甚至可以转换 Date 或者 Moment.js对象的时间戳!

!! Opérateur

Techniquement, ce n'est pas un opérateur JavaScript distinct. C'est juste l'opérateur inverse JavaScript utilisé deux fois.

Si l'expression est une valeur vraie, renvoyez vrai sinon, renvoyez faux ;

~ Non-opérateurs

Soyons réalistes : personne ne se soucie des opérateurs au niveau du bit. Quand pouvons-nous l'utiliser !

Voici un cas d'utilisation quotidienne pour l'opérateur tilde ou bitwise NOT.

Il s'avère que l'opérateur NOT est efficace lorsqu'il est utilisé avec des nombres ~N => -(N+1) Cette expression n'est évaluée à "0" que lorsque N est -1.

Nous pouvons en profiter en mettant ~ devant la fonction indexOf(…), qui effectue une vérification booléenne si l'élément existe dans la chaîne ou le tableau.

Remarque : ES6 et ES7 ont ajouté une nouvelle méthode .include() pour les chaînes et les tableaux respectivement. Bien sûr, c'est une manière plus simple de vérifier si un élément existe dans un tableau ou une chaîne que l'opérateur tilde. Utilisation des balises

les instructions break et continue peuvent être utilisées conjointement avec l'instruction lebel pour revenir à un emplacement spécifique dans le code. Utilisé pour les boucles imbriquées afin de réduire le nombre de boucles.

Tutoriel recommandé : "Tutoriel vidéo JavaScript"

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!