Namespace ( eng. namespace ) - et eller andet sæt , som betyder en model, abstrakt lager eller miljø skabt til den logiske gruppering af unikke identifikatorer (det vil sige navne).
En identifikator, der er defineret i et navneområde, er knyttet til dette navneområde . Den samme identifikator kan defineres uafhængigt i flere mellemrum. En værdi, der er knyttet til en identifikator, der er defineret i et navneområde, kan således have eller ikke have samme værdi som den samme identifikator, der er defineret i et andet navneområde. Navneområde-bevidste sprog definerer regler , der angiver, hvilket navneområde en identifikator tilhører (dvs. dens definition).
For eksempel arbejder Andrey i virksomhed X, og hans ID (forkortet fra den engelske Identifier - identifier) som ansat er 123. Oleg arbejder i virksomhed Y, og hans ID er også 123. Det eneste (fra det punkt, visning af et bestemt regnskabssystem), takket være, hvad Andrey og Oleg kan skelnes med matchende ID'er, er deres tilhørsforhold til forskellige virksomheder. Forskellen mellem virksomheder i dette tilfælde er et system med forskellige navnerum (et firma - et mellemrum). Tilstedeværelsen af to medarbejdere i en virksomhed med samme ID giver store problemer ved brug af dem, for eksempel vil det være meget vanskeligt at afgøre, hvilken medarbejder denne check er tiltænkt ud fra en lønseddel, der vil angive en medarbejder med ID 123.
I store databaser kan der være hundreder eller tusinder af identifikatorer. Navneområder (eller lignende strukturer ) giver en mekanisme til at skjule lokale identifikatorer. Deres betydning er at gruppere logisk relaterede identifikatorer i deres respektive navneområder, hvilket gør systemet modulært . Begrænsning af synligheden af variabler kan også gøres ved at specificere dens lagerklasse .
Operativsystemer , mange moderne programmeringssprog understøtter deres egen navnerumsmodel: de bruger mapper (eller mapper) som en navnerumsmodel. Dette tillader to filer med samme navn at eksistere (så længe de er i forskellige mapper). I nogle programmeringssprog (f.eks. C++ , Python ) er pladsnavne-id'er i sig selv forbundet med de tilsvarende mellemrum. På disse sprog kan navnerum derfor bygge ind i hinanden og danne et træ af navnerum. Roden til et sådant træ kaldes det globale navneområde .
I programmeringssprog kan en af måderne at angive navnerumsgrænsen være at bruge den såkaldte. omfang .
Navnerummet er defineret af en blok af instruktioner:
navneområde foo { int bar ; }Inden for denne blok kan identifikatorer kaldes nøjagtigt, som de blev erklæret. Men uden for blokken skal navneområdet angives før identifikatoren. For eksempel skal uden namespace foofor identifikatoren barangives som foo::bar. C++ indeholder nogle andre konstruktioner, der gør disse krav valgfrie. Så når du tilføjer en linje
bruger navneområde foo ;kode, behøver du foo::ikke længere at angive et præfiks. Et andet eksempel:
navneområde Navneområde12 { int foo = 0 ; } void func1 () { ved hjælp af navneområde Namespace12 ; // nu vil alle navne fra navneområdet Namespace12 være synlige her uden yderligere præfikser ++ foo ; } void func2 () { // og her skal navnet angives: Namespace12 :: foo = 42 ; }Kode, der ikke er eksplicit erklæret i navneområdet, antages at være erklæret i det globale navneområde.
Navneområdeopløsning i C++ er hierarkisk. Det betyder, at i et hypotetisk navneområde еда::супvil identifikatoren курицаstå for еда::суп::курица(hvis mellemrummet findes). Hvis det ikke findes, så peger det på еда::курица(hvis det rum findes). Hvis dette rum heller ikke eksisterer, så курицаrefererer det til en identifikator i det globale rum.
Navneområder bruges ofte i C++ for at undgå navnekollisioner .
navneområde { int a ; void f () { /*...*/ } int g () { /*...*/ } }Du kan ikke få adgang til et medlem af et anonymt navneområde fra en oversættelsesenhed fra en anden enhed.
Selvom navnerum er meget brugt i moderne kode, har meget af den ældre kode ikke disse funktioner. For eksempel er hele C++ standardbiblioteket defineret i namespace std, men før standardiseringen blev mange komponenter oprindeligt defineret i det globale rum.
Du kan også synliggøre ikke hele rummet, men individuelle navne indenfor det, for eksempel:
navneområde foo { int bar ; int noget andet ; } int main () { ved hjælp af foo :: bar ; //Gør kun bar synlig, noget andet usynlig! returnere 0 ; }Ideen med navnerum er inkorporeret i Java-pakker . Al kode er defineret i en pakke, og pakken behøver ikke et eksplicit navn. Kode fra andre pakker er tilgængelig ved at sætte pakkenavnet foran med den tilsvarende identifikator, for eksempel kan en klasse Stringi en pakke java.langkaldes som java.lang.String(dette er kendt som et fuldt kvalificeret klassenavn ). importSom i C++ giver Java en konstruktion, der gør det valgfrit at angive pakkenavnet ( ). Nogle funktioner (såsom refleksion ) kræver dog, at programmøren bruger det fuldt kvalificerede navn.
I modsætning til C++ er Java-navneområder ikke hierarkisk ordnet på grund af selve sprogets syntaks. Imidlertid er pakker navngivet i en hierarkisk stil. For eksempel er alle pakker, der begynder med java, en del af Java-platformen - pakken java.langindeholder sprogets basisklasser og java.lang.reflectindeholder de basisklasser, der er specifikke for refleksion (refleksion).
I Java (såvel som i Ada , C# og andre sprog) afspejler navnerum/pakker de semantiske kategorier af kode. For eksempel, i C# namespace Systemindeholder kode, der er implementeret af systemet ( .NET platform ). Hvordan præcist disse kategorier defineres, og hvor dybt hierarkiet er, afhænger af sproget selv.
OmfangEn funktion og en klasse kan defineres som et implicit navneområde, der er indviklet relateret til objektets synlighed, tilgængelighed og levetid .
Der er navnerum i C#-sproget, brugen ligner C++.
I Python er ideen om navnerum implementeret i moduler. (Samme som i Java-pakker)
På trods af manglen på formel støtte til navnerum er de nemme at implementere ved hjælp af sprogets objektkoncept:
var NameSpace_1 = {}; var NameSpace_2 = nyt objekt (); //to navnerum NameSpace_1 . a = 100 _ NameSpace_2 . a = "Jordbær" ; // Variable a - hver har sin egen with ( NameSpace_1 ) // Angiv standardnavneområdet { a += 10 ; NameSpace_2 . a += a ; //Variabel et navneområde NameSpace_2 vil være lig med "Strawberry110" }I XML definerer specifikationen af XML-navneområder unikheden af element- og attributnavne i et dokument, svarende til rollen som navnerum i et programmeringssprog. Med navneområder kan XML-dokumenter indeholde element- eller attributnavne fra mere end én XML-ordbog.
<rdf:RDF xmlns:rdf= "http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:foaf= "http://xmlns.com/foaf/0.1/" xmlns:rdfs= "http://www.w3.org/2000/01/rdf-schema#" > <foaf:Person rdf:about= "#JW" > …xmlns (XML-navneområde) - XML-navneområde. RDF (for at oprette et RDF-dokument ) , FOAF og RDF - skema ( RDF-designformat ) er inkluderet.
FOAF er også rummet for et RDF -dokument, så dets design kontrolleres i henhold til ordforrådet (regler, specifikationer ) for RDF .
Siden version 5.3.0 har PHP introduceret konceptet med et navneområde.
<?php navneområde mit\navn ; // definere et nyt navneområde class MyClass {} function myfunction () {} const MYCONST = 1 ; $a = ny MyClass ; // kalder inde i mit\navn mellemrum $c = nyt \mit\navn\MinKlasse ; // brug fulde navn inklusive navneområdenavn $d = new \globalClass ; // kalder en klasse fra det globale navneområde ?>En vigtig pointe. Navneområdedirektivet skal være den første kodelinje i filen. Undtagelsen er nøgleordet declare, som kan gå forud for navneområdedirektivet. Selv HTML-output før den første "<?php"-konstruktion er ikke tilladt.
Syntaksbeskrivelsen findes på PHP-projektets officielle hjemmeside [1] .
Standard Common Lisp-syntaksen har tabelnavneområder implementeret gennem pakkesystemet [2] . For at bruge en identifikator (symbol) skal du angive dets fulde navn: pakkenavn, kolon og navnet på selve symbolet [3] .
Allegro Common Lisp implementerer en ikke-standard Common Lisp-udvidelse - hierarkiske navneområder, hvor pakker er adskilt af en prik i Java -stilen , og identifikatoren fra pakkerne er adskilt af et kolon. Det er også muligt at henvise til tilstødende noder i navnerumshierarkiet ved at angive relative stier gennem to prikker [4] . Navneområder i Common Lisp er dynamiske - de oprettes, udfyldes og ødelægges under programafvikling. , selvom den deklarative form for deres beskrivelse ved hjælp af formularen defpackage[5] hovedsageligt bruges .
I PureBasic 5.20 blev navnerumsunderstøttelse introduceret, implementeret som moduler. Navnerummet er defineret af modulet og EndModule-blokken af kommandoer og afhænger ikke af placeringen i kildefilerne. Det betyder, at der i én fil kan være flere moduler, eller omvendt - modulkoden kan opdeles i flere filer. Som standard er hele modulrummet skjult, og for at synliggøre dets individuelle elementer skal de erklæres i en speciel blok af kommandoer DeclareModule / EndDeclareModule. Alt, hvad der ikke er erklæret i denne blok, er ikke tilgængeligt uden for modulet, og forsøg på at få adgang vil resultere i en adgangskrænkelsesmeddelelse fra compileren.
DeclareModule Count x = 0 ; Offentlige elementer Declare Counter () EndDeclareModule Modulantal _ y = 0 _ Private elementer Modprocedure ( ) y + 1 ProcedureReturn y EndProcedure EndModule Antal: : x = 10 ; At skrive et tal til en variabel (f.eks.). Debug Count :: Tæller () ; Kald en procedure ved hjælp af modulnavnet. UseModule Count ; Tilknytning af et modul til det aktuelle rum. Debug Counter () ; Adgang til offentlige (offentlige) elementer uden at angive modulnavnet. UnuseModule Count ; Annuller handlingen UseModule.For at få adgang til modulelementer fra et andet modul eller globalt rum, skal du angive modulnavnet og dets element, for eksempel: Count::x. Du kan også bruge kommandoen UseModule, som giver dig mulighed for at vise alle synlige modulelementer i det aktuelle rum. Dens handling annulleres af kommandoen UnuseModule. Det skal bemærkes, at det er muligt at vise de synlige elementer i flere moduler på samme tid, forudsat at der ikke er navnekonflikt. Lad os sige, at projektet har moduler med navnene x, y og z.
UseModule x UseModule y ; Koden. Brug Modul z ; Mere kode. UnuseModule y ; Mere kode. UnuseModule x UnuseModule zDette eksempel viser, at det er muligt at tilknytte flere moduler til det aktuelle rum, og også at rækkefølgen, hvori modulelementer vises og annulleres, ikke er vigtig.
I programmeringssprog uden indbygget understøttelse af navnerum kan mellemrum emuleres af en udvidelse ved hjælp af identifikatornavnekonventioner . For eksempel bruger C - biblioteker som Libpng ofte et fast præfiks for alle funktioner og variabler som en del af deres frontend. Libpng understøtter eksterne identifikatorer såsom:
png_create_write_struct png_get_signature png_read_row png_set_invalidDette giver en rimelig garanti for, at identifikatorerne vil være unikke og dermed kan bruges i store programmer uden frygt for identifikatornavnekollisioner .
Ulemperne ved navnerumsemulering inkluderer :