Questo è noto con molti nomi diversi e probabilmente chiamato ancora di più. E a volte quello che pensi è il tipo di aliasing in una lingua è qualcosa di completamente diverso in un'altra.
In Perl, hai il codice che assomiglia a:
#!/usr/bin/perl
package Foo::Bar::Qux::Bletch;
$var = 42;
package main;
print $Foo::Bar::Qux::Bletch::var, "\n";
*A = *Foo::Bar::Qux::Bletch::var;
print $A,"\n";
Che è noto da varie cose come un alias typeglob o solo alias di glob - anche se dovrebbe essere realizzato che a glob è un'altra cosa.
In Clojure, questo è semplicemente un alias:
user=> (require 'clojure.string)
nil
user=> (alias 'string 'clojure.string)
nil
user=> (string/capitalize "hONdURas")
"Honduras"
In Ruby sembra avere il nome dell'alias dello spazio dei nomi come descritto in ruby-forum: Namespace anche looooooong
However it occurred to me that there is a difference between
namespace aliases in PHP and the closest thing in Ruby (as
described above): Autoloading.
In PHP, questo è di nuovo, un alias del namespace - php.net: Uso degli spazi dei nomi: Alias / Importazione
The ability to refer to an external fully qualified name with an alias, or importing, is an important feature of namespaces. This is similar to the ability of unix-based filesystems to create symbolic links to a file or to a directory.
PHP namespaces support three kinds of aliasing or importing: aliasing a class name, aliasing an interface name, and aliasing a namespace name. Note that importing a function or constant is not supported.
In Lisp, questo non fa parte del linguaggio standard ma ci sono librerie che lo fanno e si chiamano 'alias locale del pacchetto' o 'nickname'. Una di queste librerie è cl-package-alias che fornisce alcune funzionalità aggiuntive:
* (defpackage :foo (:use :cl) (:alias (:common-lisp :bar)))
# <PACKAGE "FOO">
* (in-package :foo)
# <PACKAGE "FOO">
* (bar:format t "Hello World~%")
Hello World
NIL
In python, questo è un alias di namespace. (Esempi da Puoi definire alias per i moduli importati in Python? )
import a_ridiculously_long_module_name as short_name
Anche se puoi farlo anche con un assalto
import long_module_name
lmn = long_module_name
In C # questo è un alias dello spazio dei nomi.
Da Java equivalente a C # usando alias
namespace TheirNamespace
{
public class ContestedClassName
{
}
}
namespace MyNamespace
{
public class ContestedClassName
{
}
}
namespace MyBoundaryNamespace
{
using MyRenamedClass = MyNamespace.ContestedClassName;
using TheirRenamedClass = TheirNamespace.ContestedClassName;
public class Translator
{
public TheirRenamedClass Translate(MyRenamedClass value)
{
return null;
}
}
}
In Java, uno non sostituisce alias un namespace, ma importa elementi specifici nello spazio dei nomi corrente, anche se risponde alla domanda posta (come ridurre la quantità di battitura):
Il codice
double r = cos(Math.PI * theta);
può essere ridotto con un'importazione statica in:
import static java.lang.Math.PI;
...
double r = cos(PI * theta);
Uno spesso vede questo utilizzo con Junit per evitare di dover specificare ogni metodo statico.
import static org.junit.Assert.*;
Quando le persone parlano di tipo aliasing in Java è più lungo le linee di:
A problem I often encounter in Java is that I want to say “these two
things are the same”, but Java won’t let me. Suppose I want to
maintain an int[] array which is always sorted in my program.
che ottiene più dell'alias tipo piuttosto che dell'alias namespace , perché sono cose diverse.
Il tipo di aliasing in Scala sembra essere qualcosa di completamente diverso in base a Principiante : Alias tipo Scala in Scala 2.10? e Alias tipo Scala incluso companion opporsi
Ulteriori informazioni su quale tipo di aliasing in Scala è disponibile all'indirizzo Scala efficace
In C ++ 11 tipo alias sono un tipo di typedef che fa più cose altro di giocoleria namespace.
using identifier = type_name;
Un esempio di questo sarebbe:
// type alias, identical to
// typedef void (*func)(int, int);
using func = void (*) (int,int);
// the name 'func' now denotes a pointer to function:
void example(int, int) {}
func fn = example;
Pur comprendendo, ci sono alcune differenze tra questi concetti come descritti in Differenza tra alias typedef e C ++ 11
La riproduzione di namespace tuttavia, è un alias di namespace come descritto in In C ++, cos'è un" alias namespace "?
namespace ublas = boost::numeric::ublas;
ublas::vector<double> v;
Maggiori informazioni su questo alias dello spazio dei nomi msdn
namespace a_very_long_namespace_name { ... }
namespace AVLNN = a_very_long_namespace_name;
// AVLNN is now a namespace-alias for a_very_long_namespace_name.
Il link mostra alcune lingue con varie forme di alias dello spazio dei nomi.
OCaml:
module Gr = Graphics;;
Haskell:
import qualified Data.Bytestring as B
Gli spazi dei nomi non sono unici per i linguaggi di programmazione, ma si estendono anche ad altri dati strutturati come XSL che ha alias di namespace. Questi tendono ad essere trasformazioni piuttosto concise (convertendo 'alt' in 'xsl' o qualcosa di simile - ma servono allo stesso scopo.
Quindi, come notato, questi concetti hanno nomi diversi in diverse lingue e ciò che è noto come "type aliasing" in una lingua può significare qualcosa completamente diverso in un'altra lingua.
Non esiste un nome standard