Symbool (programmeren) - Symbol (programming)

Een symbool in computerprogrammering is een primitief gegevenstype waarvan de instanties een unieke door mensen leesbare vorm hebben. Symbolen kunnen worden gebruikt als identificatiegegevens . In sommige programmeertalen worden ze atomen genoemd . Uniciteit wordt afgedwongen door ze in een symbolentabel te houden . Het meest gebruikt door programmeurs symbolen is voor het uitvoeren taal reflectie (in het bijzonder voor callbacks ), en meest voorkomende indirect is hun gebruik object bindingen .

In de meest triviale implementatie worden ze in wezen gehele getallen genoemd (bijvoorbeeld het opgesomde type in C).

Ondersteuning

De volgende programmeertalen bieden runtime- ondersteuning voor symbolen:

Lisp

Een symbool in Lisp is uniek in een naamruimte (of pakket in Common Lisp ). Symbolen kunnen op gelijkheid worden getest met de functie EQ. Lisp-programma's kunnen tijdens runtime nieuwe symbolen genereren. Wanneer Lisp gegevens leest die tekstueel vertegenwoordigde symbolen bevatten, wordt verwezen naar bestaande symbolen. Als een symbool onbekend is, maakt de Lisp-lezer een nieuw symbool aan.

In Common Lisp hebben symbolen de volgende attributen: een naam, een waarde, een functie, een lijst met eigenschappen en een pakket.

In Common Lisp is het ook mogelijk dat een symbool niet in een pakket zit. Dergelijke symbolen kunnen worden afgedrukt, maar bij het teruglezen moet een nieuw symbool worden gemaakt. Omdat het niet * geïnterneerd * is, kan het originele symbool niet uit een pakket worden opgehaald.

In Common Lisp mogen symbolen alle tekens gebruiken, inclusief witruimte, zoals spaties en nieuwe regels. Als een symbool een witruimte-teken bevat, moet het worden geschreven als | dit is een symbool |. Symbolen kunnen worden gebruikt als identificatiegegevens voor elk soort benoemde programmeerconstructies: variabelen, functies, macro's, klassen, typen, ga naar tags en meer. Symbolen kunnen in een pakket worden opgenomen. Sleutelwoordsymbolen zijn zelfevaluerend en zitten in het pakket met de naam KEYWORD.

Voorbeelden

Het volgende is een eenvoudige externe weergave van een Common Lisp- symbool:

this-is-a-symbol

Symbolen kunnen spaties bevatten (en alle andere tekens):

|This is a symbol with whitespace|

In Common Lisp zijn symbolen met een voorloopkomma in hun gedrukte weergave trefwoordsymbolen . Deze zijn opgenomen in het trefwoordenpakket.

:keyword-symbol

Een gedrukte weergave van een symbool kan een pakketnaam bevatten. Er staan ​​twee dubbele punten tussen de naam van het pakket en de naam van het symbool.

package-name::symbol-name

Pakketten kunnen symbolen exporteren. Dan wordt er slechts één dubbele punt tussen de naam van het pakket en de naam van het symbool geschreven.

package:exported-symbol

Symbolen die niet in een pakket zijn opgenomen, kunnen ook worden gemaakt en hebben een notatie:

#:uninterned-symbol

Prolog

In Prolog zijn symbolen (of atomen) de primaire primitieve gegevenstypen, vergelijkbaar met getallen. De exacte notatie kan verschillen in de verschillende Prolog-dialecten. Het is echter altijd vrij eenvoudig (aanhalingstekens of speciale begintekens zijn niet nodig).

In tegenstelling tot andere talen, is het mogelijk om symbolen een betekenis te geven door enkele feiten en / of regels van Prolog te creëren.

Voorbeelden

Het volgende voorbeeld laat twee feiten zien (die beschrijft wat vader is) en één regel (die de betekenis van broer of zus beschrijft ). Deze drie zinnen gebruiken symbolen (vader, zeus, hermes, perseus en broer of zus) en enkele abstracte variabelen (X, Y en Z). De moederrelatie is voor de duidelijkheid weggelaten.

father(zeus, hermes).
father(zeus, perseus).

sibling(X, Y) :- father(Z, X), father(Z, Y).

Robijn

In Ruby kunnen symbolen worden gemaakt met een letterlijke vorm of door een string te converteren. Ze kunnen worden gebruikt als identificatie of als een geïnterneerde string. Twee symbolen met dezelfde inhoud verwijzen altijd naar hetzelfde object. Het wordt als een best practice beschouwd om symbolen te gebruiken als sleutels voor een associatieve array in Ruby.

Voorbeelden

Het volgende is een eenvoudig voorbeeld van een letterlijk symbool in Ruby:

my_symbol = :a
my_symbol = :"an identifier"

Strings kunnen in symbolen worden omgezet, vice versa:

irb(main):001:0> my_symbol = "Hello, world!".intern 
=> :"Hello, world!"
irb(main):002:0> my_symbol = "Hello, world!".to_sym 
=> :"Hello, world!"
irb(main):003:0> my_string = :hello.to_s
=> "hello"

Symbolen zijn objecten van de Symbol klasse in Ruby:

irb(main):004:0> my_symbol = :hello_world
=> :hello_world
irb(main):005:0> my_symbol.length 
=> 11
irb(main):006:0> my_symbol.class 
=> Symbol

Symbolen worden vaak gebruikt om dynamisch berichten te verzenden naar (oproepmethoden voor) objecten:

irb(main):007:0> "aoboc".split("o")
=> ["a", "b", "c"]
irb(main):008:0> "aoboc".send(:split, "o") # same result
=> ["a", "b", "c"]

Symbolen als sleutels van een associatieve array:

irb(main):009:0> my_hash = { a: "apple", b: "banana" }
=> {:a=>"apple", :b=>"banana"}
irb(main):010:0> my_hash[:a] 
=> "apple"
irb(main):011:0> my_hash[:b] 
=> "banana"

Koetjes en kalfjes

In Smalltalk kunnen symbolen worden gemaakt met een letterlijke vorm, of door een string te converteren. Ze kunnen worden gebruikt als identificator of als een geïnterneerde string. Twee symbolen met dezelfde inhoud verwijzen altijd naar hetzelfde object. In de meeste Smalltalk-implementaties worden selectors (methodenamen) geïmplementeerd als symbolen.

Voorbeelden

Het volgende is een eenvoudig voorbeeld van een letterlijk symbool in Smalltalk:

my_symbol := #'an identifier' " Symbol literal "
my_symbol := #a               " Technically, this is a selector literal. In most implementations, "
                              " selectors are symbols, so this is also a symbol literal "

Strings kunnen in symbolen worden omgezet, vice versa:

my_symbol := 'Hello, world!' asSymbol " => #'Hello, world!' "
my_string := #hello: asString         " => 'hello:' "

Symbolen voldoen aan het symbol protocol en hun klasse wordt Symbol in de meeste implementaties aangeroepen :

my_symbol := #hello_world
my_symbol class            " => Symbol "

Symbolen worden vaak gebruikt om dynamisch berichten te verzenden naar (oproepmethoden voor) objecten:

" same as 'foo' at: 2 "
'foo' perform: #at: with: 2 " => $o "

Referenties