Create an object/Native demonstration: Difference between revisions

{{draft task}}

 

 

 

If the language supports '''Magic Methods''', then show how these work.

 

=={{header|D}}==

{{trans|Python}}

TV[TK] standard, current;

 

this.standard = default_;

this.current = default_.dup;

}

 

current = standard.dup;

}

void main() {

import std.stdio;

 

d["a"] = 55; d["b"] = 66;

d["a"] = 55; d["b"] = 66;

d.remove("a");

{{out}}

<pre>["a":1, "b":2]

55

["a":1, "b":66]</pre>

 

=={{header|J}}==

Given a list of keys and an associated list of values, the idiomatic way of expressing this concept in J would be:

 

 

For example:

 

lookup ;:'a test'

 

Notes:

 

3) In J, objects are always referenced, but all data is passed by value. This means that objects can never be passed to a function -- only a reference to an object (its name) can be passed. This means that objects exist only in the way things are named, in J. So for the most part, we do not call things "objects" in J, and this task has nothing to do with what are called "objects" in J. However, this does demonstrate how things are created in J -- you write their definition, and can use them and/or assign to names or inspect them or whatever else.

 

=={{header|JavaScript}}==

{{works with|JavaScript|1.7}}

 

 

function FixedKeyDict(obj)

return "FixedKeyDict{" + s + "}" ;

} ;

 

Test run:

 

const BR = "<BR>\n"

 

pl("error test : " + e.message) ;

}

 

output :

</pre>

 

a[2] = "Native demonstration";

Example usage:

<pre>a[3] = 2

->Set::write: Tag a in a[1] is Protected. >>

</pre>

=={{header|Perl}}==

use Carp;

 

sub TIEHASH {

}

 

my $ref = shift;

tie(%$ref, __PACKAGE__, %$ref);

# add a new key x: will die

eval { $h{x} = 1 };

b => 4

c => 5

operation error: Can't add key x at test.pl line 14

LockedHash::STORE('LockedHash=HASH(0x8cebe14)', 'x', 1) called at test.pl line 66

 

 

=={{header|Python}}==

from collections import UserDict

import copy

raise KeyError

else:

 

=={{header|Racket}}==

 

Implementation of functions that handle fenced-hash:

;(struct fenced-hash (actual original) ...)

 

;private custom-write ;mode is ignored

(write-string "#fenced-hash" port)

 

Definition of the actual structure and a “public” creator:

#:extra-constructor-name *fenced-hash ;private constructor

#:omit-define-syntaxes ;not sure this is a good idea

(define (fenced-hash . args) ; public constructor

(define original (apply hash args))

 

'''Example:''' Use the fenced-hash functions:

 

(displayln d)

(displayln d)

(fenced-hash-remove! d "a")

{{out}}

<pre>#fenced-hash(("b" . 2) ("a" . 1))

 

'''Example (continued):''' Use the same object as a dict. The dict-clear! method is not defined, so we must call fenced-hash-clear! instead.

(displayln d)

(dict-set! d "a" 55)

(displayln d)

(dict-remove! d "a")

{{out}}

<pre>#fenced-hash(("b" . 2) ("a" . 1))

#fenced-hash(("b" . 66) ("a" . 1))</pre>

 

 

 

 

 

 

 

 

 

 

end

end

 

super

end

 

end

 

end

 

#

else

end

end

 

self

end

 

end

 

end

 

 

end

 

end

 

else

end

end

 

 

end

 

end

 

end

 

end

 

end

 

end

 

end

 

end

 

end

 

end

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

{{omit from|AWK|Cannot tie the []= operator nor the delete command to custom functions.}}

{{omit from|C|No associative arrays.}}

{{omit from|dc|No associative arrays.}}

{{omit from|GUISS}}

{{omit from|PureBasic}}

{{omit from|sed|No associative arrays.}}

{{omit from|UNIX Shell|Bourne shell does not have these, but bashisms may be available on some shells}}

{{omit from|PicoLisp|Can't change the behavior of the property system without changing the language around it.}}