Use

Getter methods are useful for:

• Defining virtual properties on a map.
• Defining property values that change with their internal set value.

Virtual properties

Virtual properties are properties that don't actually store any value, but derive their value from some other properties on the map.

Whenever a getter is provided, it is wrapped in a can-compute, which ensures that whenever its dependent properties change, a change event will fire for this property also.

const Person = DefineMap.extend( {
    first: "string",
    last: "string",
    fullName: {
        get: function() {
            return this.first + " " + this.last;
        }
    }
} );

const p = new Person( { first: "Justin", last: "Meyer" } );

p.fullName; // "Justin Meyer"

p.on( "fullName", function( ev, newVal ) {
    newVal; //-> "Lincoln Meyer";
} );

p.first = "Lincoln";

Asynchronous virtual properties

Often, a virtual property's value only becomes available after some period of time. For example, given a personId, one might want to retrieve a related person:

const AppState = DefineMap.extend( {
    personId: "number",
    person: {
        get: function( lastSetValue, resolve ) {
            Person.get( { id: this.personId } )
                .then( function( person ) {
                    resolve( person );
                } );
        }
    }
} );

Asynchronous properties should be bound to before reading their value. If they are not bound to, the get function will be called each time.

The following example will make multiple Person.get requests:

const state = new AppState( { personId: 5 } );
state.person; //-> undefined

// called sometime later /* ... */
state.person; //-> undefined

However, by binding, the compute only reruns the get function once personId changes:

const state = new AppState( { personId: 5 } );

state.on( "person", function() {} );

state.person; //-> undefined

// called sometime later
state.person; //-> Person<{id: 5}>

A template like can-stache will automatically bind for you, so you can pass state to the template like the following without binding:

const template = stache( "<span>{{person.fullName}}</span>" );
const state = new AppState( {} );
const frag = template( state );

state.personId = 5;
frag.childNodes[ 0 ].innerHTML; //=> ""

// sometime later
frag.childNodes[ 0 ].innerHTML; //=> "Lincoln Meyer"

The magic tags are updated as personId, person, and fullName change.

Properties values that change with their internal set value

A getter can be used to derive a value from a set value. A getter's lastSetValue argument is the last value set by instance.propertyName = value.

For example, a property might be set to a compute, but when read, provides the value of the compute.

const MyMap = DefineMap.extend( {
    value: {
        get: function( lastSetValue ) {
            return lastSetValue();
        }
    }
} );

const map = new MyMap();
const compute = compute( 1 );
map.value = compute;

map.value; //-> 1
compute( 2 );
map.value; //-> 2

This technique should only be used when the lastSetValue is some form of observable, that when it changes, can update the getter value.

For simple conversions, set or type should be used.

Updating the virtual property value

It's common to update virtual property values instead of replacing it.

The following example creates an empty locationIds can-define/list/list when a new instance of Store is created. However, as locations change, the can-define/list/list will be updated with the ids of the locations.

const Store = DefineMap.extend( {
    locations: DefineList,
    locationIds: {
        Default: DefineList,
        get: function( initialValue ) {
            const ids = this.locations.map( function( location ) {
                ids.push( location.id );
            } );
            return initialValue.replace( ids );
        }
    }
} );