DoneJS StealJS jQuery ++ FuncUnit DocumentJS
3.0.0
2.3.27

 

  • Github
  • Twitter
  • Chat
  • Forum
  • Guides
  • Core
    • can-component
    • can-compute
    • can-connect
    • can-define
    • can-define/list/list
    • can-define/map/map
      • events
        • __keys
        • propertyName
      • static
        • extend
        • seal
      • prototype
        • forEach
        • get
        • on
        • serialize
        • set
        • *
    • can-route
    • can-route-pushstate
    • can-set
    • can-stache
    • can-stache/helpers/route
    • can-stache-bindings
  • Ecosystem
  • Infrastructure
  • Legacy
  • Bitovi
    • Bitovi.com
    • Blog
    • Consulting
    • Training
    • Open Source
  • Chat
  • Forum
  • Star
  • Follow @canjs
  • CanJS
  • /
  • Core
  • /
  • can-define/map/map
  • /
  • extend
  • / On this page
    • extend

      function

      Define a custom map type.

      • source

      DefineMap.extend([name,] [static,] prototype)

      Extends DefineMap, or constructor functions derived from DefineMap, to create a new constructor function.

      var DefineMap = require("can-define/map/map");
      
      var Person = DefineMap.extend(
        "Person",
        {seal: true},
        {
          first: "string",
          last: {type: "string"},
          fullName: {
            get: function(){
              return this.first+" "+this.last;
            }
          },
          age: {value: 0},
        });
      
      var me = new Person({first: "Justin", last: "Meyer"})
      me.fullName //-> "Justin Meyer"
      me.age      //-> 0
      

      Parameters

      1. name {String}:

        Provides an optional name for this type that will show up nicely in debuggers.

      2. static {Object}:

        Static properties that are set directly on the constructor function.

      3. prototype {Object<String,function|PropDefinition>}:

        A definition of the properties or methods on this type.

        If the property definition is a plain function, it's considered a method.

        var Person = DefineMap.extend({
          sayHi: function(){ console.log("hi"); }
        });
        
        var me = new Person();
        me.sayHi();
        

        If the property definition is a string, it's considered a type setting to be looked up in can-define.types.

        var Person = DefineMap.extend({
          age: 'number',
          isCool: 'boolean',
          hobbies: 'observable'
        });
        
        var me = new Person({age: '33', isCool: 'false', hobbies: ['js','bball']});
        me.age    //-> 33
        me.isCool //-> false
        me.hobbies instanceof DefineList //-> true
        

        If the property definition is a Constructor function, it's considered a Type setting.

        var Address = DefineMap.extend({
          zip: 'number'
        });
        var Person = DefineMap.extend({
          address: Address
        });
        
        var me = new Person({address: {zip: '60048'}});
        me.address.zip //-> 60048
        

        If the property is an object, it's considered to be a PropDefinition.

        var Person = DefineMap.extend({
          fullName: {
            get: function() {
              return this.first+" "+this.last;
            },
            set: function(newVal) {
              var parts = newVal.split(" ");
              this.first = parts[0];
              this.last = parts[1];
            }
          },
          // slick way of creating an 'inline' type.
          address: {
            Type: {
              zip: "number"
            }
          }
        });
        
        var me = new Person({fullName: "Rami Myer", address: {zip: '60048'}});
        me.first       //-> "Rami"
        me.address.zip //-> 60048
        

      Returns

      {can-define/map/map}:

      A DefineMap constructor function.

      CanJS is part of DoneJS. Created and maintained by the core DoneJS team and Bitovi. Currently 3.0.0.