浅析JavaScript中的同名标识符优先级_javascript技巧
一,局部变量先使用后声明,不影响外部同名变量
var x = 1; // --> 外部变量x
function fn(){
alert(x); // --> undefined 局部变量x先使用
var x = 2; // 后声明且赋值
}
fn();
alert(x); // --> 1
第一点,函数fn内第一句输出x,x是在第二句才定义的。这在JS中是允许的,这里的允许是指不会出现语法错误程序可以运行。
但在其它语言如C,Java中却是不允许的。变量必须先声明后使用,如
public class Test {
public static void main(String[] args) {
System.out.println(x); // 先使用
int x = 10; // 后声明
}
}
Java中编译器会提示错误,程序无法运行。
第二点,函数fn内的局部变量x不会影响到外部的变量x。即fn内alert输出不是1,而是undefined。
二,形参优先级高于函数名
function fn(fn){
alert(fn);
}
fn('hello'); // --> "hello"
可以看到函数名和形参同名都是fn,输出的是字符串"hello",却不是函数fn的函数体(fn.toString())。
三,形参优先级高于arguments
function fn(arguments){
alert(arguments);
}
fn('hello'); // --> "hello"
arguments对象可以直接在函数内使用,是语言本身提供的一个 特殊标识符 。
这里刚好将形参声明成与其同名。输出可以看到是"hello"而非"[object Object]",即形参arguments覆盖了语言本身提供的真正的arguments。
四,形参优先级高于只声明却未赋值的局部变量
function fn(a){
var a;
alert(a);
}
fn('hello'); // --> "hello"
函数fn形参为a,函数内第一句仅声明局部变量a,却并未赋值。从输出结果是"hello"而非undefined可以看出形参a优先级高于仅声明却未赋值的局部变量a。
五,声明且赋值的局部变量优先级高于形参
function fn(a){
var a = 1;
alert(a);
}
fn('hello'); // --> "1"
函数fn形参为a,函数内第一句仅声明局部变量a,赋值为1。从输出结果是"1"而非"hello"可以看出声明且赋值的局部变量a优先级高于形参a。
六,形参赋值给同名局部变量时
function fn(a){
var a = a;
alert(a);
}
fn('hello');
暂不运行,猜测下结果。如果按照第五点:声明且赋值的局部变量优先级高于形参。那么a将是undefined。但实际上a是"hello",即右a是形参a,左a才是局部变量a。

这里的两个a互不干扰,谁也没覆盖谁。这与刚刚说的赋值的局部变量优先级高于形参又矛盾了。但引擎这样做的确是我们想要的,因为并不希望var a = a后a是undefined。

Outils d'IA chauds

Undresser.AI Undress
Application basée sur l'IA pour créer des photos de nu réalistes

AI Clothes Remover
Outil d'IA en ligne pour supprimer les vêtements des photos.

Undress AI Tool
Images de déshabillage gratuites

Clothoff.io
Dissolvant de vêtements AI

Video Face Swap
Échangez les visages dans n'importe quelle vidéo sans effort grâce à notre outil d'échange de visage AI entièrement gratuit !

Article chaud

Outils chauds

Bloc-notes++7.3.1
Éditeur de code facile à utiliser et gratuit

SublimeText3 version chinoise
Version chinoise, très simple à utiliser

Envoyer Studio 13.0.1
Puissant environnement de développement intégré PHP

Dreamweaver CS6
Outils de développement Web visuel

SublimeText3 version Mac
Logiciel d'édition de code au niveau de Dieu (SublimeText3)

Lors du développement de programmes utilisant le langage de programmation C++, nous rencontrons souvent des erreurs « identifiant non trouvé ». Ce message d'erreur signifie généralement que le compilateur ne trouve pas la définition d'une variable, d'une fonction ou d'une classe. Cet article expliquera la cause de cette erreur et comment la corriger. Raisons pour lesquelles l'identifiant ne peut pas être trouvé Tout d'abord, examinons pourquoi l'erreur « Identifiant non trouvé » se produit. Cette erreur a généralement les raisons suivantes : 1.1 La variable, la fonction ou la classe n'est pas définie. C'est l'une des raisons les plus courantes pour lesquelles "identifiant n'est pas trouvé". si un

Les exigences relatives aux identifiants légaux en langage C sont les suivantes : 1. L'identifiant ne peut être composé que de lettres (A~Z, a~z), de chiffres (0~9) et de traits de soulignement (_). 2. Le premier caractère doit être une lettre ; ou Les traits de soulignement ne peuvent pas être des chiffres ; 3. Les lettres majuscules et minuscules de l'identifiant sont différentes et représentent des significations différentes. 4. L'identifiant ne peut pas être un mot-clé ;

Dans le langage Go, les identifiants sont utilisés pour nommer des entités. Les règles de grammaire incluent le début par une lettre ou un trait de soulignement, peuvent contenir des lettres, des chiffres ou des traits de soulignement et ne peuvent pas être des mots-clés réservés. Sémantiquement, les identifiants de constante commençant par une lettre majuscule représentent des valeurs immuables, les identifiants de variable commençant par une lettre minuscule représentent des valeurs mutables, les identifiants de type commençant par une lettre majuscule représentent un ensemble de valeurs et les identifiants de fonction commençant par une lettre minuscule sont généralement précédés de Func. préfixe. Comprendre ces règles et sémantiques est essentiel pour créer un code clair et maintenable.

En JavaScript, les identifiants font référence aux noms utilisés par les utilisateurs lors de la programmation. Ils sont utilisés pour nommer des variables, des constantes, des fonctions, des blocs d'instructions, etc., pour établir une relation entre les noms et les utilisations. Les identifiants sont généralement constitués de lettres, de chiffres et d'autres caractères ; .constituer. Le premier caractère d'un identifiant légal doit être une lettre, un trait de soulignement ou un signe dollar ; il ne peut pas avoir le même nom qu'un mot clé JavaScript ou un mot réservé.

Les identifiants sont utilisés pour toute variable, fonction, définition de données, étiquette, etc. dans un programme. Avant de démarrer une langue, vous devez au moins savoir nommer les identifiants. En langage C, un identifiant est une combinaison de caractères alphanumériques, c'est-à-dire qu'il commence par une lettre ou un trait de soulignement, et le reste est une lettre, n'importe quel chiffre ou un trait de soulignement. Règles de dénomination des identifiants Les règles à suivre lors de la dénomination des identifiants sont les suivantes : - La casse des caractères alphabétiques est importante. Par exemple, utiliser « TUTORIAL » pour une variable est différent de l'utilisation de « tutoriel » pour une variable, et est différent de l'utilisation de « TutoRial » pour une variable. Les trois variables font référence à des variables différentes. Il n’y a aucune exigence concernant la longueur des identifiants. Nous pouvons avoir des problèmes avec certains compilateurs si l'identifiant dépasse 31 caractères. pour

Il existe trois types d'identifiants en langage C : 1. Les mots-clés, qui sont des chaînes avec des significations spécifiques spécifiées par le langage C, souvent également appelés mots réservés. 2. Les identifiants prédéfinis, qui sont des identifiants prédéfinis par le système, tels que les bibliothèques de fonctions. La fonction ; noms, définitions de macros et alias de type dans ; 3. Les identifiants définis par l'utilisateur sont des identifiants définis par les utilisateurs en fonction de leurs propres besoins. Ils sont généralement utilisés pour nommer des variables, des fonctions, des tableaux, etc. Si l'identifiant de l'utilisateur est identique à un mot-clé, une erreur se produira lors de la compilation ; s'il est identique à un identifiant prédéfini, aucune erreur ne se produira lors de la compilation, mais la signification originale de l'identifiant prédéfini est perdue.

Go règles de dénomination des identifiants : les identifiants doivent commencer par une lettre ou un trait de soulignement, sont sensibles à la casse et évitent d'utiliser des mots-clés. Les meilleures pratiques incluent l'utilisation de la notation camelCase, l'évitement des abréviations et le respect de la cohérence. Le respect de ces règles peut améliorer la lisibilité, la maintenabilité et la qualité de votre code, améliorant ainsi la compréhensibilité de votre base de code.

Les symboles autorisés pour les identifiants en PHP incluent les lettres, les chiffres, les traits de soulignement et les caractères chinois. Introduction détaillée : 1. Les identifiants peuvent être composés de lettres et de chiffres. Ils peuvent commencer par une lettre et peuvent être suivis de n'importe quel nombre de lettres, de chiffres ou de traits de soulignement. 2. Les identifiants peuvent contenir des traits de soulignement, mais pas de traits de soulignement. . début ; 3. Caractères chinois À partir de la version 7.2 de PHP, les caractères chinois peuvent être utilisés dans les identifiants $Chinese, les fonctions chinoises (), etc. sont tous des identifiants légaux, etc.
