Textarea Character Limit

HTML:

<textarea maxlength="50" id="text">This textarea has a character limit of 50.</textarea>

Javascript:

function maxLength(el) {    
    if (!('maxLength' in el)) {
        var max = el.attributes.maxLength.value;
        el.onkeypress = function () {
            if (this.value.length >= max) return false;
        };
    }
}

maxLength(document.getElementById("text"));
Advertisements

Mongoose Type in Schema

Schema Types

SchemaTypes take care of validation, casting, defaults, and other general options in our models. We can specify our types one of two ways:

// directly without options
var Person = new Schema({
    title   : String
});

// or with options
var Person = new Schema({
    title   : { type: String, lowercase: true }
});

In the example above we specified the lowercase option for strings which will lowercase the string whenever it is set. Options are functions that are called on each SchemaType. Each SchemaType has its own set of custom options.

Available Schema Types

String

  • lowercase: {Boolean}

    Creates a setter which calls .toLowerCase() on the value

  • uppercase: {Boolean}

    Creates a setter which calls .toUpperCase() on the value

  • trim: {Boolean}

    Creates a setter which calls .trim() on the value

  • match: {RegExp}

    Creates a RegExp based validator. The value being set is .test()ed against the RegExp. If it does not pass, validation will fail.

  • enum: {Array}

    Creates an enum validator. If the value being set is not in this array, validation will fail.

Number

  • min: {Number}

    Creates a validator which checks that the value being set is not less than the value specified.

  • max: {Number}

    Creates a validator which checks that the value being set is not greater than the value specified.

Date

  • no custom options

Boolean

  • no custom options

Buffer (v2.x only)

  • no custom options

ObjectId

To specify a type of ObjectId, use Schema.ObjectId in your declaration.

var mongoose = require('mongoose');
var Schema = mongoose.Schema;
var Car = new Schema({ driver: Schema.ObjectId })
  • no custom options

Mixed

An “anything goes” SchemaType, its flexibility comes at a trade-off of it being harder to maintain. Mixed is available either through Schema.Types.Mixed or by passing an empty object literal. The following are equivalent:

var Any = new Schema({ any: {} });
var Any = new Schema({ any: Schema.Types.Mixed });

Since it is a schema-less type, you can change the value to anything else you like, but Mongoose loses the ability to auto detect/save those changes. To “tell” Mongoose that the value of a Mixed type has changed, call the .markModified(path) method of the document passing the path to the Mixed type you just changed.

person.anything = { x: [3, 4, { y: "changed" }] };
person.markModified('anything');
person.save(); // anything will now get saved
  • no custom options

Array

Creates an array of SchemaTypes or Embedded Documents.

var ToySchema = new Schema({ name: String });
var ToyBox = new Schema({
    toys: [ToySchema]
  , buffers: [Buffer]
  , string:  [String]
  , numbers: [Number]
  ... etc
});

Note: specifying an empty array is equivalent to [Mixed]. The following all create arrays of Mixed:

var Empty1 = new Schema({ any: [] });
var Empty2 = new Schema({ any: Array });
var Empty3 = new Schema({ any: [Schema.Types.Mixed] });
var Empty4 = new Schema({ any: [{}] });
  • no custom options

Additional options

Besides the options listed above, all SchemaTypes share the following additional options.

  • default: {Function|value} – Determines the default value for the path. All values are casted. If using a function, the value it returns will be casted as the default value.
  • required: {Boolean} – If true, creates a validation rule requiring this path be set before saving occurs.
  • select: {Boolean} – Specifies default path selection behavior. In other words, you can specify if this path should be included or excluded from query results by default.
    // Excluding `bio` from query results by default
    
    
    var Person = new Schema({ bio: { type: String, select: false }})
    var P = db.model('Person', Person);
    P.findOne(function (err, p) {
      console.log(p.bio) // undefined
    });
    
    
    // Including `name` in query results by default
    
    
    var Person = new Schema({
        name: { type: String, select: true }
      , age: Number
    })
    
    
    var P = db.model('Person', Person);
    P.findOne().select('age').exec(function (err, p) {
      console.log(p.isSelected('age'))  // true
      console.log(p.isSelected('name')) // true
    });
    
    
    // can also be overridden on a query by query basis
    
    
    var Person = new Schema({ bio: { type: String, select: false }})
    var P = db.model('Person', Person);
    P.findOne().select('bio').exec(callback); // bio will be selected
    
  • get: {Function} – Adds a getter for this path. See the getters / setters docs for more detail.
  • set: {Function} – Adds a setter for this path. See the getters / setters docs for more detail.
  • index: {Boolean|Object} – Tells Mongoose to ensure an index is created for this path. An object can be passed as well.
    var Person = new Schema({ name: { type: String, index: true }})
    
    
    var name = { type: String, index: { unique: true }}
    var Person = new Schema({ name: name })
    

    Note: if the index already exists on the db, it will not be replaced.

  • unique: {Boolean} – Tells Mongoose to ensure a unique index is created for this path. The following are equivalent:
    var Person = new Schema({ name: { type: String, unique: true }})
    
    
    var name = { type: String, index: { unique: true }}
    var Person = new Schema({ name: name })
    

    Note: if the index already exists on the db, it will not be replaced.

  • sparse: {Boolean} – Tells Mongoose to ensure a sparse index is created for this path. The following are equivalent:
    var Person = new Schema({ name: { type: String, sparse: true }})
    
    
    var name = { type: String, index: { sparse: true }}
    var Person = new Schema({ name: name })
    

    Note: if the index already exists on the db, it will not be replaced.

  • validate: {Function|RegExp|Array} – Creates a validator for this path.
    // passing a function
    function hasNumber (v) {
      return v.length && /\d/.test(v);
    }
    var street = { type: String, validate: hasNumber }
    var Person = new Schema({ street: street });
    
    
    // passing a RegExp
    var street = { type: String, validate: /\d/ }
    var Person = new Schema({ street: street });
    
    
    // passing an array
    var street = {
        type: String
      , validate: [hasNumber, 'street number required']
    }
    var Person = new Schema({ street: street })
    
    
    // or
    var street = {
        type: String
      , validate: [/\d/, 'street number required']
    }
    var Person = new Schema({ street: street });
    

    For more detail about validation including async validation, see the validation page.

Alternate options definition

Instead of defining options when instanciating your Schema we can also access keys through the path function and add options there:

Person.path('age').max(400);

Person.path('meta.birth').set(function (v) {
  // this is a setter
});

Person.path('title').validate(function (v) {
  return v.length > 50;
});

Ubuntu Install Node8

curl -sL https://deb.nodesource.com/setup_8.x | sudo -E bash -

Then
## Run `sudo apt-get install -y nodejs` to install Node.js 8.x LTS Carbon and npm
## You may also need development tools to build native addons:
– sudo apt-get install gcc g++ make
## To install the Yarn package manager, run:
– curl -sL https://dl.yarnpkg.com/debian/pubkey.gpg | sudo apt-key add –
– echo “deb https://dl.yarnpkg.com/debian/ stable main” | sudo tee /etc/apt/sources.list.d/yarn.list
– sudo apt-get update && sudo apt-get install yarn

MySQL CAST DECIMAL to INT

You could try the FLOOR function like this:

SELECT FLOOR(columnName), moreColumns, etc 
FROM myTable 
WHERE ... 

You could also try the FORMAT function, provided you know the decimal places can be omitted:

SELECT FORMAT(columnName,0), moreColumns, etc 
FROM myTable 
WHERE ... 

You could combine the two functions

SELECT FORMAT(FLOOR(columnName),0), moreColumns, etc 
FROM myTable 
WHERE ...