Options

• default {default()}:

  Specifies the initial value of the property or a function that returns the initial value.

  import {DefineMap} from "can";
  // A default age of `0`:
  const Person = DefineMap.extend( {
   age: {
   default: 0
   },
   address: {
   default: function() {
   return { city: "Chicago", state: "IL" };
   }
   }
  } );
  const person = new Person();
  console.log( person.age ); //-> 0
  

• Default {Default()}:

  Specifies a function that will be called with new whose result is set as the initial value of the attribute.

  import {DefineMap, DefineList} from "can";
  // A default empty DefineList of hobbies:
  const Person = DefineMap.extend( {
   hobbies: { Default: DefineList }
  } );
  const person = new Person();
  console.log( person.hobbies instanceof DefineList ); //-> true
  

• type {type()}:

  Specifies the type of the property. The type can be specified as either a function that returns the type coerced value or one of the types names.

  import {DefineMap} from "can";
  const Person = DefineMap.extend( {
   age: { type: "number" },
   hobbies: {
   type: function( newValue ) {
   if ( typeof newValue === "string" ) {
   return newValue.split( "," );
   } else if ( Array.isArray( newValue ) ) {
   return newValue;
   }
   }
   }
  } );
  const person = new Person({ age: "20", hobbies: "basketball,billiards,dancing" });
  console.log( person.age, person.hobbies ); //-> 20, ["basketball", "billiards", "dancing"]
  

• Type {Type()}:

  A constructor function that takes the assigned property value as the first argument and called with new. For example, the following will call new Address(newValue) with whatever non null, undefined, or address type is set as a Person's address property.

  import {DefineMap} from "can";
  const Address = DefineMap.extend( {
   street: "string",
   state: "string"
  } );
  const Person = DefineMap.extend( {
   address: { Type: Address }
  } );
  const person = new Person({
   address: {
   street: "Example Ave.",
   state: "IL"
   }
  });
  console.log( person.address.serialize() ); //-> {state: "IL", street: "Example Ave."}
  

• get {get(lastSetValue)}:

  A function that specifies how the value is retrieved. The get function is converted to an async compute. It should derive its value from other values on the object. The following defines a page getter that reads from a map's offset and limit:

  import {DefineMap} from "can";
  const Book = DefineMap.extend( {
   offset: "number",
   limit: "number",
   page: {
   get: function( newVal ) {
   return Math.floor( this.offset / this.limit ) + 1;
   }
   }
  } );
  const book = new Book( {offset: 10, limit: 5} );
  console.log( book.page ) //-> 3
  

  A get definition makes the property computed which means it will not be enumerable by default.

• value {value()}:

  A function that listens to events and resolves the value of the property. This should be used when get is unable to model the right behavior. The following counts the number of times the page property changes:

  import {DefineMap} from "can";
  const Book = DefineMap.extend( {
   page: "number",
   pageChangeCount: {
   value( prop ) {
   let count = 0;
   // When page changes, update the count.
   prop.listenTo( "page", function() {
   prop.resolve( ++count );
   } );
   // Set initial count.
   prop.resolve( count );
   }
   }
  } );
  const book = new Book();
  book.on("pageChangeCount", () => {});
  book.page = 1;
  book.page += 1;
  console.log( book.pageChangeCount ); //-> 2
  

  A value definition makes the property computed which means it will not be enumerable by default.

• set {set(newVal, resolve)}:

  A set function that specifies what should happen when a property is set. set is called with the result of type or Type. The following defines a page setter that updates the map's offset:

  import {DefineMap} from "can";
  const Book = DefineMap.extend( {
   offset: "number",
   limit: "number",
   page: {
   set: function( newVal ) {
   this.offset = ( parseInt( newVal ) - 1 ) * this.limit;
   }
   }
  } );
  const book = new Book({ limit: 5 });
  book.page = 10;
  console.log( book.offset ); //-> 45
  

• serialize {serialize()}:

  Specifies the behavior of the property when serialize is called.

  By default, serialize does not include computed values. Properties with a get definition are computed and therefore are not added to the result. Non-computed properties values are serialized if possible and added to the result.

  import {DefineMap} from "can";
  const Todo = DefineMap.extend( {
   date: {
   type: "date",
   serialize: function( value ) {
   return value.getTime();
   }
   }
  } );
  const todo = new Todo( {date: Date.now()} );
  console.log( todo.serialize() ); //-> {date: 1535751516915}
  

• identity {identity}:

  Specifies the property that uniquely identifies instances of the type.

  import {DefineMap, Reflect} from "can";
  const Grade = DefineMap.extend( "Grade", {
   classId: {type: "number", identity: true},
   studentId: {type: "number", identity: true},
   grade: "string"
  } );
  const myGrade = new Grade( {classId: 12345, studentId: 54321, grade: "A+"} )
  console.log(Reflect.getIdentity(myGrade)); //-> "{'classId':12345,'studentId':54321}"