浅析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。

Heiße KI -Werkzeuge

Undresser.AI Undress
KI-gestützte App zum Erstellen realistischer Aktfotos

AI Clothes Remover
Online-KI-Tool zum Entfernen von Kleidung aus Fotos.

Undress AI Tool
Ausziehbilder kostenlos

Clothoff.io
KI-Kleiderentferner

Video Face Swap
Tauschen Sie Gesichter in jedem Video mühelos mit unserem völlig kostenlosen KI-Gesichtstausch-Tool aus!

Heißer Artikel

Heiße Werkzeuge

Notepad++7.3.1
Einfach zu bedienender und kostenloser Code-Editor

SublimeText3 chinesische Version
Chinesische Version, sehr einfach zu bedienen

Senden Sie Studio 13.0.1
Leistungsstarke integrierte PHP-Entwicklungsumgebung

Dreamweaver CS6
Visuelle Webentwicklungstools

SublimeText3 Mac-Version
Codebearbeitungssoftware auf Gottesniveau (SublimeText3)

Heiße Themen



Bei der Entwicklung von Programmen mit der Programmiersprache C++ treten häufig Fehler auf, bei denen der Bezeichner nicht gefunden wurde. Diese Fehlermeldung bedeutet normalerweise, dass der Compiler die Definition einer Variablen, Funktion oder Klasse nicht finden kann. In diesem Artikel wird die Ursache dieses Fehlers erläutert und wie er behoben werden kann. Gründe, warum der Bezeichner nicht gefunden werden kann Schauen wir uns zunächst an, warum der Fehler „Bezeichner nicht gefunden“ auftritt. Dieser Fehler hat normalerweise folgende Gründe: 1.1 Die Variable, Funktion oder Klasse ist nicht definiert. Dies ist einer der häufigsten Gründe für „Bezeichner nicht gefunden“. wenn a

Die Anforderungen für gültige Bezeichner in der Sprache C sind: 1. Der Bezeichner darf nur aus Buchstaben (A~Z, a~z), Zahlen (0~9) und Unterstrichen (_) bestehen. 2. Das erste Zeichen muss ein Buchstabe sein oder Unterstriche dürfen keine Zahlen sein. 3. Die Groß- und Kleinbuchstaben im Bezeichner sind unterschiedlich und haben unterschiedliche Bedeutungen. 4. Der Bezeichner darf kein Schlüsselwort sein.

In der Go-Sprache werden Bezeichner zum Benennen von Entitäten verwendet. Sie beginnen mit einem Buchstaben oder einem Unterstrich, können Buchstaben, Zahlen oder Unterstriche enthalten und können keine reservierten Schlüsselwörter sein. Semantisch gesehen stellen Konstantenbezeichner, die mit einem Großbuchstaben beginnen, unveränderliche Werte dar, Variablenbezeichner, die mit einem Kleinbuchstaben beginnen, stellen veränderliche Werte dar, Typbezeichner, die mit einem Großbuchstaben beginnen, stellen eine Reihe von Werten dar, und Funktionsbezeichner, die mit einem Kleinbuchstaben beginnen, werden normalerweise durch Func vorangestellt Präfix. Das Verständnis dieser Regeln und Semantik ist entscheidend für die Erstellung klaren, wartbaren Codes.

In JavaScript beziehen sich Bezeichner auf Namen, die von Benutzern beim Programmieren verwendet werden. Sie werden zum Benennen von Variablen, Konstanten, Funktionen, Anweisungsblöcken usw. verwendet, um eine Beziehung zwischen Namen herzustellen. Bezeichner bestehen normalerweise aus Buchstaben, Zahlen und anderen Zeichen . bilden. Das erste Zeichen einer gültigen Kennung muss ein Buchstabe, ein Unterstrich oder ein Dollarzeichen sein; es darf nicht derselbe Name wie ein JavaScript-Schlüsselwort oder ein reserviertes Wort sein.

Bezeichner werden für alle Variablen, Funktionen, Datendefinitionen, Beschriftungen usw. in einem Programm verwendet. Bevor Sie mit einer Sprache beginnen, müssen Sie zumindest wissen, wie Bezeichner benannt werden. In der C-Sprache ist ein Bezeichner eine Kombination aus alphanumerischen Zeichen, d. h. er beginnt mit einem Buchstaben oder einem Unterstrich und der Rest ist ein Buchstabe, eine beliebige Zahl oder ein Unterstrich. Regeln für die Benennung von Bezeichnern Die Regeln, die bei der Benennung von Bezeichnern befolgt werden müssen, lauten wie folgt: Die Groß-/Kleinschreibung von alphabetischen Zeichen ist wichtig. Beispielsweise unterscheidet sich die Verwendung von „TUTORIAL“ für eine Variable von der Verwendung von „tutorial“ für eine Variable und von der Verwendung von „Tutorial“ für eine Variable. Diese drei Variablen beziehen sich alle auf unterschiedliche Variablen. Es gibt keine Anforderung an die Länge der Bezeichner. Bei einigen Compilern kann es zu Problemen kommen, wenn der Bezeichner länger als 31 Zeichen ist. für

Es gibt drei Arten von C-Sprachbezeichnern: 1. Schlüsselwörter, bei denen es sich um Zeichenfolgen mit einer bestimmten, von der C-Sprache angegebenen Bedeutung handelt, die häufig auch als reservierte Wörter bezeichnet werden. 2. Vordefinierte Bezeichner, bei denen es sich um vom System vordefinierte Bezeichner handelt, z. B. Funktionsbibliotheken Namen, Makrodefinitionen und Typaliase in; 3. Benutzerdefinierte Bezeichner sind Bezeichner, die von Benutzern entsprechend ihren eigenen Anforderungen definiert werden. Sie werden im Allgemeinen zum Benennen von Variablen, Funktionen, Arrays usw. verwendet. Wenn der Benutzerbezeichner mit einem Schlüsselwort übereinstimmt, tritt beim Kompilieren ein Fehler auf. Wenn er mit einem vordefinierten Bezeichner übereinstimmt, tritt beim Kompilieren kein Fehler auf, aber die ursprüngliche Bedeutung des vordefinierten Bezeichners geht verloren.

Regeln für die Benennung von Go-Bezeichnern: Bezeichner müssen mit einem Buchstaben oder Unterstrich beginnen, die Groß-/Kleinschreibung muss beachtet werden und die Verwendung von Schlüsselwörtern ist zu vermeiden. Zu den Best Practices gehören die Verwendung der CamelCase-Notation, die Vermeidung von Abkürzungen und die Beachtung der Konsistenz. Das Befolgen dieser Regeln kann die Lesbarkeit, Wartbarkeit und Qualität Ihres Codes verbessern und dadurch die Verständlichkeit Ihrer Codebasis verbessern.

Zu den in PHP für Bezeichner zulässigen Symbolen gehören Buchstaben, Zahlen, Unterstriche und chinesische Schriftzeichen. Ausführliche Einführung: 1. Bezeichner können aus Buchstaben und Zahlen bestehen und können von einer beliebigen Anzahl von Buchstaben, Zahlen oder Unterstrichen gefolgt werden . Anfang; 3. Chinesische Zeichen dürfen in Bezeichnern, chinesischen Funktionen () usw. verwendet werden.
