This article needs additional citations for verification .(December 2018) |
In computer programming, scope is an enclosing context where values and expressions are associated. The scope resolution operator helps to identify and specify the context to which an identifier refers, particularly by specifying a namespace or class. The specific uses vary across different programming languages with the notions of scoping. In many languages, the scope resolution operator is written ::
.
In some languages, notably those influenced by Modula-3 (including Python and Go), modules are objects, and scope resolution within modules is a special case of usual object member access, so the usual method operator .
is used for scope resolution. Other languages, notably C++ and Ruby, feature both scope resolution and method access, which interact in various ways; see examples below.
classA{public:staticinti;// scope of i is A};namespaceB{intc=2;}// namespace BintA::i=4;// scope operator refers to the integer i declared in the class Aintx=B::c;// scope operator refers to the integer c declared in the namespace B
In PHP, the scope resolution operator is also called Paamayim Nekudotayim (Hebrew : פעמיים נקודותיים, pronounced [paʔaˈmajimnekudoˈtajim] , the second word a colloquial corruption of נקודתיים, pronounced [nekudaˈtajim] ), which means “double colon” in Hebrew.
The name "Paamayim Nekudotayim" was introduced in the Israeli-developed [1] Zend Engine 0.5 used in PHP 3. Although it has been confusing to many developers who do not speak Hebrew, it is still being used in PHP 7, as in this sample error message:
$ php-r:: Parse error: syntax error, unexpected T_PAAMAYIM_NEKUDOTAYIM
A similar error can also occur where no scope resolution operator is present. For example, attempting to check whether a constant is empty() triggers this error:
$ php-r'define("foo", "bar"); if (empty(foo)) echo "empty";'Parse error: syntax error, unexpected ')', expecting T_PAAMAYIM_NEKUDOTAYIM
As of PHP 5.4, error messages concerning the scope resolution operator still include this name, but have clarified its meaning somewhat:
$ php-r:: Parse error: syntax error, unexpected '::' (T_PAAMAYIM_NEKUDOTAYIM)
There are other less obvious ways to trigger the error, for example by attempting to use the following invalid PHP expression:
$ php-rstaticconst'$a=1'Parse error: syntax error, unexpected end of file, expecting :: (T_PAAMAYIM_NEKUDOTAYIM)
In Ruby, scope resolution can be specified using the module keyword.
moduleExampleVersion=1.0class<<self# We are accessing the module's singleton classdefhello(who="world")"Hello #{who}"endendend#/ExampleExample::hello# => "Hello world"Example.hello"hacker"# => "Hello hacker"Example::Version# => 1.0Example.Version# NoMethodError# This illustrates the difference between the message (.) operator and the scope operator in Ruby (::)# We can use both ::hello and .hello, because hello is a part of Example's scope and because Example# responds to the message hello.## We can't do the same with ::Version and .Version, because Version is within the scope of Example, but# Example can't respond to the message Version, since there is no method to respond with.
Scope is also affected by sigils which preface variable names:
$
" - global variable @
" - instance variable of self
@@
" - class variable In computing, a namespace is a set of signs (names) that are used to identify and refer to objects of various kinds. A namespace ensures that all of a given set of objects have unique names so that they can be easily identified.
In computer programming, the scope of a name binding is the part of a program where the name binding is valid; that is, where the name can be used to refer to the entity. In other parts of the program, the name may refer to a different entity, or to nothing at all. Scope helps prevent name collisions by allowing the same name to refer to different objects – as long as the names have separate scopes. The scope of a name binding is also known as the visibility of an entity, particularly in older or more technical literature—this is in relation to the referenced entity, not the referencing name.
In programming languages, a closure, also lexical closure or function closure, is a technique for implementing lexically scoped name binding in a language with first-class functions. Operationally, a closure is a record storing a function together with an environment. The environment is a mapping associating each free variable of the function with the value or reference to which the name was bound when the closure was created. Unlike a plain function, a closure allows the function to access those captured variables through the closure's copies of their values or references, even when the function is invoked outside their scope.
A string literal or anonymous string is a literal for a string value in the source code of a computer program. Modern programming languages commonly use a quoted sequence of characters, formally "bracketed delimiters", as in, where is a string literal with value. Methods such as escape sequences can be used to avoid the problem of delimiter collision and allow the delimiters to be embedded in a string. There are many alternate notations for specifying string literals especially in complicated cases. The exact notation depends on the programming language in question. Nevertheless, there are general guidelines that most modern programming languages follow.
D, also known as dlang, is a multi-paradigm system programming language created by Walter Bright at Digital Mars and released in 2001. Andrei Alexandrescu joined the design and development effort in 2007. Though it originated as a re-engineering of C++, D is now a very different language drawing inspiration from other high-level programming languages, notably Java, Python, Ruby, C#, and Eiffel.
A Perl module is a discrete component of software for the Perl programming language. Technically, it is a particular set of conventions for using Perl's package mechanism that has become universally adopted.
In compiler construction, name mangling is a technique used to solve various problems caused by the need to resolve unique names for programming entities in many modern programming languages.
In computer programming, a sigil is a symbol affixed to a variable name, showing the variable's datatype or scope, usually a prefix, as in $foo
, where $
is the sigil.
In computer programming, an entry point is the place in a program where the execution of a program begins, and where the program has access to command line arguments.
In computer programming, a naming convention is a set of rules for choosing the character sequence to be used for identifiers which denote variables, types, functions, and other entities in source code and documentation.
In computer language design, stropping is a method of explicitly marking letter sequences as having a special property, such as being a keyword, or a certain type of variable or storage location, and thus inhabiting a different namespace from ordinary names ("identifiers"), in order to avoid clashes. Stropping is not used in most modern languages – instead, keywords are reserved words and cannot be used as identifiers. Stropping allows the same letter sequence to be used both as a keyword and as an identifier, and simplifies parsing in that case – for example allowing a variable named if
without clashing with the keyword if.
The syntax of the Python programming language is the set of rules that defines how a Python program will be written and interpreted. The Python language has many similarities to Perl, C, and Java. However, there are some definite differences between the languages. It supports multiple programming paradigms, including structured, object-oriented programming, and functional programming, and boasts a dynamic type system and automatic memory management.
C++11 is a version of the ISO/IEC 14882 standard for the C++ programming language. C++11 replaced the prior version of the C++ standard, called C++03, and was later replaced by C++14. The name follows the tradition of naming language versions by the publication year of the specification, though it was formerly named C++0x because it was expected to be published before 2010.
In computer programming, an anonymous function is a function definition that is not bound to an identifier. Anonymous functions are often arguments being passed to higher-order functions or used for constructing the result of a higher-order function that needs to return a function. If the function is only used once, or a limited number of times, an anonymous function may be syntactically lighter than using a named function. Anonymous functions are ubiquitous in functional programming languages and other languages with first-class functions, where they fulfil the same role for the function type as literals do for other data types.
This article describes the syntax of the C# programming language. The features described are compatible with .NET Framework and Mono.
The syntax and semantics of PHP, a programming language, form a set of rules that define how a PHP program can be written and interpreted.
This comparison of programming languages compares how object-oriented programming languages such as C++, Java, Smalltalk, Object Pascal, Perl, Python, and others manipulate data structures.
The structure of the Perl programming language encompasses both the syntactical rules of the language and the general ways in which programs are organized. Perl's design philosophy is expressed in the commonly cited motto "there's more than one way to do it". As a multi-paradigm, dynamically typed language, Perl allows a great degree of flexibility in program design. Perl also encourages modularization; this has been attributed to the component-based design structure of its Unix roots, and is responsible for the size of the CPAN archive, a community-maintained repository of more than 100,000 modules.
In programming languages, name resolution is the resolution of the tokens within program expressions to the intended program components.
The syntax of the Ruby programming language is broadly similar to that of Perl and Python. Class and method definitions are signaled by keywords, whereas code blocks can be defined by either keywords or braces. In contrast to Perl, variables are not obligatorily prefixed with a sigil. When used, the sigil changes the semantics of scope of the variable. For practical purposes there is no distinction between expressions and statements. Line breaks are significant and taken as the end of a statement; a semicolon may be equivalently used. Unlike Python, indentation is not significant.