以下程式碼是THREE.JS 原始碼檔案中Math/Vector2.js檔案的註釋.

// File:src/math/Vector2.js

/**
 * @author mrdoob / http://mrdoob.com/
 * @author philogb / http://blog.thejit.org/
 * @author egraether / http://egraether.com/
 * @author zz85 / http://www.lab4games.net/zz85/blog
 */

/*
///Vector2物件的建構函式.用來建立一個二維向量的物件.Vector2物件的功能函式採用
///定義構造的函式原型物件來實現.
///
///	用法: var p2d = new Vector2(5,3)
///	建立一個x座標為5,y座標為3的向量.
///	NOTE: 引數(x,y)座標為可選引數,如果不指定引數(x,y),將建立一個座標為(0,0)的向量.
*/
///<summary>Vector2</summary>
///<param name ="x" type="number">x座標</param>
///<param name ="y" type="number">y座標</param>
THREE.Vector2 = function ( x, y ) {

	this.x = x || 0;
	this.y = y || 0;

};

/****************************************
****下面是Vector2物件提供的功能函式.
****************************************/

THREE.Vector2.prototype = {

	constructor: THREE.Vector2,

	/*
	///set方法用來從新設定二維向量的x,y座標值.並返回新的座標值的二維向量.
	*/
	///<summary>set</summary>
	///<param name ="x" type="number">x座標</param>
	///<param name ="y" type="number">y座標</param>
	///<returns type="Vector2">返回新座標值的二維向量</returns>
	set: function ( x, y ) {

		this.x = x;
		this.y = y;

		return this;	//返回新座標值的二維向量

	},

	/*
	///setX方法用來從新設定二維向量的x座標值.並返回新的座標值的二維向量.
	*/
	///<summary>setX</summary>
	///<param name ="x" type="number">x座標</param>
	///<returns type="Vector2">返回新座標值的二維向量</returns>
	setX: function ( x ) {

		this.x = x;

		return this;	//返回新座標值的二維向量

	},

	/*
	///setY方法用來從新設定二維向量的x座標值.並返回新的座標值的二維向量.
	*/
	///<summary>setY</summary>
	///<param name ="y" type="number">y座標</param>
	///<returns type="Vector2">返回新座標值的二維向量</returns>
	setY: function ( y ) {

		this.y = y;

		return this;	//返回新座標值的二維向量

	},

	/*
	///setComponent方法用來從新設定二維向量的(x,y)座標值.並返回新的座標值的二維向量.
	///引數index取值為0 或者 1,取值為0,引數value設定x的座標值,取值為1,引數value設定y的座標.
	*/
	///<summary>setComponent</summary>
	///<param name ="index" type="number">0或1</param>
	///<param name ="value" type="number">x 或 y座標</param>
	setComponent: function ( index, value ) {

		switch ( index ) {

			case 0: this.x = value; break;
			case 1: this.y = value; break;
			default: throw new Error( 'index is out of range: ' + index );

		}

	},

	/*
	///getComponent方法用獲得二維向量的(x,y)座標值.
	///引數index取值為0 或者 1,取值為0,獲得x的座標值,取值為1,獲得y的座標.
	*/
	///<summary>setComponent</summary>
	///<param name ="index" type="number">0或1</param>
	getComponent: function ( index ) {

		switch ( index ) {

			case 0: return this.x;
			case 1: return this.y;
			default: throw new Error( 'index is out of range: ' + index );

		}

	},

	/*
	///copy方法用來複制二維向量的(x,y)座標值.並返回新的座標值的二維向量.
	*/
	///<summary>copy</summary>
	///<param name ="v" type="Vector2">二維向量</param>
	///<returns type="Vector2">返回新座標值的二維向量</returns>
	copy: function ( v ) {

		this.x = v.x;
		this.y = v.y;

		return this;	//返回新座標值的二維向量

	},


	/*
	///add方法用來將二維向量的(x,y)座標值與引數v的(x,y)相加.並返回新的座標值的二維向量.
	/// NOTE:add()方法雖然有兩個引數,但實際上只對引數v做運算,這裡的引數w,如果設定的話,呼叫.addVectors()方法.
	*/
	///<summary>add</summary>
	///<param name ="v" type="Vector2">與當前物件(x,y)座標值增加的向量</param>
	///<param name ="w" type="Vector2">判斷是否有第二個引數w,如果有的話,呼叫.addVectors()方法</param>
	///<returns type="Vector2">返回新座標值的二維向量</returns>
	add: function ( v, w ) {

		if ( w !== undefined ) {	//判斷是否有第二個引數w,如果有的話,呼叫.addVectors()方法.

			//THREE.Vector2: .add()方法現在只有一個引數,如果2個引數使用.addVectors( a, b )方法來替代.
			console.warn( 'THREE.Vector2: .add() now only accepts one argument. Use .addVectors( a, b ) instead.' );	
			return this.addVectors( v, w );

		}

		this.x += v.x;
		this.y += v.y;

		return this;	//返回新座標值的二維向量

	},

	/*
	///addVectors方法用來將二維向量的(x,y)座標值分別於引數(a,b)的(x,y)相加.並返回新的座標值的二維向量.
	*/
	///<summary>addVectors</summary>
	///<param name ="a" type="Vector2">二維向量</param>
	///<param name ="b" type="Vector2">二維向量</param>
	///<returns type="Vector2">返回新座標值的二維向量</returns>
	addVectors: function ( a, b ) {

		this.x = a.x + b.x;
		this.y = a.y + b.y;

		return this;	//返回新座標值的二維向量

	},

	/*
	///addScalar方法用來將二維向量的(x,y)座標值直接與引數s相加.並返回新的座標值的二維向量.
	/// NOTE:這裡與add()方法不同的是,這裡傳遞的引數s是一個標量,而add()方法的引數v是一個二維向量.
	*/
	///<summary>addScalar</summary>
	///<param name ="s" type="number">(x,y)要增加的數值</param>
	///<returns type="Vector2">返回新座標值的二維向量</returns>
	addScalar: function ( s ) {

		this.x += s;
		this.y += s;

		return this;	//返回新座標值的二維向量

	},

	/*
	///sub方法用來將二維向量的(x,y)座標值與引數v的(x,y)相減.並返回新的座標值的二維向量.
	/// NOTE:sub()方法雖然有兩個引數,但實際上只對引數v做運算,這裡的引數w,如果設定的話,呼叫.subVectors()方法.
	*/
	///<summary>sub</summary>
	///<param name ="v" type="Vector2">與當前物件(x,y)座標值增加的二維向量</param>
	///<param name ="w" type="Vector2">判斷是否有第二個引數w,如果有的話,呼叫.subVectors()方法</param>
	///<returns type="Vector2">返回新座標值的二維向量</returns>
	sub: function ( v, w ) {

		if ( w !== undefined ) {	//判斷是否有第二個引數w,如果有的話,呼叫.subVectors()方法.

			//THREE.Vector2: .sub()方法現在只有一個引數,如果2個引數使用.subVectors( a, b )方法來替代.
			console.warn( 'THREE.Vector2: .sub() now only accepts one argument. Use .subVectors( a, b ) instead.' );
			return this.subVectors( v, w );

		}

		this.x -= v.x;
		this.y -= v.y;

		return this;	//返回新座標值的二維向量

	},

	/*
	///subVectors方法用來將二維向量的(x,y)座標值分別於引數(a,b)的(x,y)相減.並返回新的座標值的二維向量.
	*/
	///<summary>subVectors</summary>
	///<param name ="a" type="Vector2">二維向量</param>
	///<param name ="b" type="Vector2">二維向量</param>
	///<returns type="Vector2">返回新座標值的二維向量</returns>
	subVectors: function ( a, b ) {

		this.x = a.x - b.x;
		this.y = a.y - b.y;

		return this;	//返回新座標值的二維向量

	},

	/*
	///multiply方法用來將二維向量的(x,y)座標值與引數v的(x,y)相乘.並返回新的座標值的二維向量.
	*/
	///<summary>multiply</summary>
	///<param name ="v" type="Vector2">與當前物件(x,y)值相乘的二維向量</param>
	///<returns type="Vector2">返回新座標值的二維向量</returns>
	multiply: function ( v ) {

		this.x *= v.x;
		this.y *= v.y;

		return this;	//返回新座標值的二維向量

	},

	/*
	///multiplyScalar方法用來將二維向量的(x,y)座標值直接與引數s相乘.並返回新的座標值的二維向量.
	/// NOTE:這裡與multiply()方法不同的是,這裡傳遞的引數s是一個標量,而multiply()方法的引數v是一個二維向量.
	*/
	///<summary>multiplyScalar</summary>
	///<param name ="s" type="number">與當前物件(x,y)值相乘的標量,數值</param>
	///<returns type="Vector2">返回新座標值的二維向量</returns>
	multiplyScalar: function ( s ) {

		this.x *= s;
		this.y *= s;

		return this;	//返回新座標值的二維向量

	},

	/*
	///divide方法用來將二維向量的(x,y)座標值與引數v的(x,y)相除.並返回新的座標值的二維向量.
	*/
	///<summary>divide</summary>
	///<param name ="v" type="Vector2">與當前物件(x,y)值相除的二維向量</param>
	///<returns type="Vector2">返回新座標值的二維向量</returns>
	divide: function ( v ) {

		this.x /= v.x;
		this.y /= v.y;

		return this;	//返回新座標值的二維向量

	},

	/*
	///divideScalar方法用來將二維向量的(x,y)座標值直接與引數scalar相除.並返回新的座標值的二維向量.
	/// NOTE:
	///		1. 引數scalar如果為0,當前物件(x,y)值直接設定為0!!
	///		2. 這裡與divide()方法不同的是,這裡傳遞的引數scalar是一個標量,而divide()方法的引數v是一個二維向量.
	*/
	///<summary>divideScalar</summary>
	///<param name ="scalar" type="number">與當前物件(x,y)值相除的標量,數值</param>
	///<returns type="Vector2">返回新座標值的二維向量</returns>
	divideScalar: function ( scalar ) {

		if ( scalar !== 0 ) {

			var invScalar = 1 / scalar;		//將被除數換算成小數

			this.x *= invScalar;
			this.y *= invScalar;

		} else {

			//引數scalar如果為0,當前物件(x,y)值直接設定為0!!
			this.x = 0;		
			this.y = 0;

		}

		return this;	//返回新座標值的二維向量

	},
	/*
	///min方法用來將二維向量的(x,y)座標值直接與引數v的(x,y)比較,如果當前二維向量的值大於引數v的(x,y),
	///將引數v的(x,y)賦值給當前向量,並返回(x,y)值最小的二維向量.
	*/
	///<summary>min</summary>
	///<param name ="v" type="Vector2">與當前物件(x,y)值引數v的(x,y)比較,並返回(x,y)值最小的二維向量.</param>
	///<returns type="Vector2">返回新座標值的二維向量</returns>
	min: function ( v ) {

		if ( this.x > v.x ) {		//如果當前二維向量的x值大於引數v.x

			this.x = v.x;			//將引數v的x值賦值給當前向量

		}

		if ( this.y > v.y ) {		//如果當前二維向量的y值大於引數v.y

			this.y = v.y;			//將引數v的y值賦值給當前向量

		}

		return this;	//返回新座標值的二維向量

	},

	/*
	///max方法用來將二維向量的(x,y)座標值直接與引數v的(x,y)比較,如果當前二維向量的值小於引數v的(x,y),
	///將引數v的(x,y)賦值給當前向量,並返回(x,y)值最大的二維向量.
	*/
	///<summary>min</summary>
	///<param name ="v" type="Vector2">與當前物件(x,y)值引數v的(x,y)比較,並返回(x,y)值最大的二維向量.</param>
	///<returns type="Vector2">返回新座標值的二維向量</returns>
	max: function ( v ) {

		if ( this.x < v.x ) {		//如果當前二維向量的x值小於引數v.x

			this.x = v.x;			//將引數v的x值賦值給當前向量

		}

		if ( this.y < v.y ) {		//如果當前二維向量的y值小於引數v.y

			this.y = v.y;			//將引數v的y值賦值給當前向量

		}

		return this;	//返回新座標值的二維向量

	},
	/*
	///clamp方法用來將二維向量的(x,y)座標值直接與引數min,引數max的(x,y)比較,如果當前二維向量的值小於引數min的(x,y)
	///或者大於引數max的(x,y),對應的將引數min或max的(x,y)賦值給當前二維向量,
	/// NOTE:保持當前二維向量在min,max所組成的二維空間的之內,最大不超過max的(x,y)值,最小不小於min的(x,y)值.
	*/
	///<summary>clamp</summary>
	///<param name ="min" type="Vector2">二維向量.</param>
	///<param name ="max" type="Vector2">二維向量.</param>
	///<returns type="Vector2">返回指定界限內的二維向量</returns>
	clamp: function ( min, max ) {

		// This function assumes min < max, if this assumption isn't true it will not operate correctly
		// 這個方法用來獲得二維向量的最小值於最大值,如果沒有獲取到,說明函式執行錯誤.


		if ( this.x < min.x ) {				//如果當前二維向量的x值小於引數min的x值

			this.x = min.x;					//將引數min的x值賦值給當前向量

		} else if ( this.x > max.x ) {		//如果當前二維向量的x值大於引數max的x值

			this.x = max.x;					//將引數max的x值賦值給當前向量

		}

		if ( this.y < min.y ) {				//如果當前二維向量的y值小於引數min的x值

			this.y = min.y;					//將引數min的y值賦值給當前向量

		} else if ( this.y > max.y ) {		//如果當前二維向量的y值小於引數max的y值

			this.y = max.y;					//將引數max的y值賦值給當前向量

		}

		return this;	//返回指定界限內的二維向量
	},
	/*
	///clampScalar方法用來將二維向量的(x,y)座標值直接與引數minVal,引數maxVal比較,如果當前二維向量的值小於引數minVal
	///或者大於引數maxVal,將引數minVal或maxVal賦值給當前二維向量,
	/// NOTE:
	///		1. 保持當前二維向量在minVal,maxVal所組成的二維空間的之內,最大不超過maxVal值,最小不小於minVal值.
	///		2. 這裡與clamp()方法不同的是,這裡傳遞的引數minVal,maxVal是一個標量,而clamp()方法的引數min,引數max是兩個二維向量.
	*/
	///<summary>clampScalar</summary>
	///<param name ="minVal" type="number">下限.</param>
	///<param name ="maxVal" type="number">上限.</param>
	///<returns type="Vector2">返回指定界限內的二維向量</returns>
	clampScalar: ( function () {	//外側括號是一種特殊的用法,似乎代表立即執行.小白,請見諒!

		var min, max;

		return function ( minVal, maxVal ) {	//建立匿名函式

			if ( min === undefined ) {

				min = new THREE.Vector2();
				max = new THREE.Vector2();

			}

			min.set( minVal, minVal );
			max.set( maxVal, maxVal );

			return this.clamp( min, max );	//呼叫clamp()方法,返回指定界限內的二維向量

		};

	} )(),

	/*
	///floor方法用來返回小於或等於二維向量的(x,y)座標值的最大整數
	/// NOTE:去掉小數部分
	*/
	///<summary>floor</summary>
	///<returns type="Vector2">返回圓整後的二維向量</returns>
	floor: function () {

		this.x = Math.floor( this.x );
		this.y = Math.floor( this.y );

		return this;	//返回圓整後的二維向量

	},

	/*
	///ceil方法用來返回大於或等於二維向量的(x,y)座標值的最小整數
	/// NOTE:將小數部分去掉加1.
	*/
	///<summary>ceil</summary>
	///<returns type="Vector2">返回圓整後的二維向量</returns>
	ceil: function () {

		this.x = Math.ceil( this.x );
		this.y = Math.ceil( this.y );

		return this;	//返回圓整後的二維向量

	},

	/*
	///round方法用來返回最接近二維向量的(x,y)座標值的整數
	/// NOTE:也就是四捨五入
	*/
	///<summary>round</summary>
	///<returns type="Vector2">返回圓整後的二維向量</returns>
	round: function () {

		this.x = Math.round( this.x );
		this.y = Math.round( this.y );

		return this;	//返回圓整後的二維向量

	},

	/*
	///roundToZero方法將當前二維向量的(x,y)座標值若為負數時,返回大於或等於二維向量的(x,y)座標值的最小整數
	///	而當前二維向量的(x,y)座標值若為正數時,返回小於或等於二維向量的(x,y)座標值的最大整數
	*/
	///<summary>roundToZero</summary>
	///<returns type="Vector2">返回圓整後的二維向量</returns>
	roundToZero: function () {

		this.x = ( this.x < 0 ) ? Math.ceil( this.x ) : Math.floor( this.x );
		this.y = ( this.y < 0 ) ? Math.ceil( this.y ) : Math.floor( this.y );

		return this;	//返回新座標值的二維向量

	},

	/*
	///negate方法將當前二維向量的(x,y)座標值若為負數時,返回正數.
	///	而當前二維向量的(x,y)座標值若為正數時,返回負數.
	/// NOTE:取當前二維向量的(x,y)座標值相反數
	*/
	///<summary>negate</summary>
	///<returns type="Vector2">返回取相反數後的二維向量</returns>
	negate: function () {

		this.x = - this.x;
		this.y = - this.y;

		return this;	//返回新座標值的二維向量

	},

	/*
	///dot方法將返回兩個向量的點乘積(點乘,數量積).
	/// NOTE:關於點積的介紹參考維基百科:http://zh.wikipedia.org/wiki/%E6%95%B0%E9%87%8F%E7%A7%AF
	*/
	///<summary>dot</summary>
	///<param name ="v" type="Vector2">二維向量</param>
	///<returns type="number">返回點乘積(點乘,數量積)</returns>
	dot: function ( v ) {

		return this.x * v.x + this.y * v.y;

	},

	/*
	///lengthSq方法將返回這個向量的長度的平方（只讀）.
	/// NOTE：勾股定理a^2 + b^2 = c^2,這裡返回的是c^2.
	*/
	///<summary>lengthSq</summary>
	///<returns type="number">返回向量的長度的平方（只讀）</returns>
	lengthSq: function () {

		return this.x * this.x + this.y * this.y;	//返回向量的長度的平方（只讀）

	},

	/*
	///length方法將返回向量的長度（只讀）.
	/// NOTE：勾股定理a^2 + b^2 = c^2,c=Math.sqrt(a^2 + b^2),這裡返回的是c.
	*/
	///<summary>length</summary>
	///<returns type="number">返回向量的長度（只讀）</returns>
	length: function () {

		return Math.sqrt( this.x * this.x + this.y * this.y );	//返回向量的長度（只讀）

	},

	/*
	///normalize方法將返回向量的長度為1（只讀）.
	/// 複習一下初中的幾何吧,三角恆等式,給你準備好了 :) ,見維基百科:
	/// http://zh.wikipedia.org/wiki/%E4%B8%89%E8%A7%92%E5%87%BD%E6%95%B0#.E4.B8.89.E8.A7.92.E6.81.92.E7.AD.89.E5.BC.8F
	*/
	///<summary>normalize</summary>
	///<returns type="number">返回向量的長度為1（只讀）</returns>
	normalize: function () {

		return this.divideScalar( this.length() );		//返回向量的長度為1（只讀）

	},

	/*
	///distanceTo方法將返回當前二維向量到引數v的距離(只讀).
	*/
	///<summary>distanceTo</summary>
	///<param name ="v" type="Vector2">二維向量</param>
	///<returns type="Vector2">返回當前二維向量到引數v的距離(只讀).</returns>
	distanceTo: function ( v ) {

		return Math.sqrt( this.distanceToSquared( v ) );	//返回當前二維向量到引數v的距離(只讀).

	},

	/*
	///distanceToSquared方法將返回當前二維向量到引數v的距離的點積(點乘,數量積)(只讀).
	/// NOTE:關於點積的介紹參考維基百科:http://zh.wikipedia.org/wiki/%E6%95%B0%E9%87%8F%E7%A7%AF
	*/
	///<summary>distanceToSquared</summary>
	///<param name ="v" type="Vector2">二維向量</param>
	///<returns type="Vector2">返回當前二維向量到引數v的距離的點積(點乘,數量積)(只讀)</returns>
	distanceToSquared: function ( v ) {

		var dx = this.x - v.x, dy = this.y - v.y;
		return dx * dx + dy * dy;					//當前二維向量到引數v的距離的點積(點乘,數量積)(只讀).

	},

	/*
	///setLength方法用來按照引數l(長度)設定新的二維向量(x,y)值.
	/// NOTE:將以原點到當前向量的線段等比例縮放到引數l所指定的長度.
	*/
	///<summary>setLength</summary>
	///<param name ="l" type="number">指定的長度</param>
	///<returns type="Vector2">返回按照引數l(長度)設定新的二維向量(x,y)值.</returns>
	setLength: function ( l ) {

		var oldLength = this.length();

		if ( oldLength !== 0 && l !== oldLength ) {		//做個判斷,如果原長度與新長度不相等,並且原長度不為0.

			this.multiplyScalar( l / oldLength );		//呼叫.multiplyScalar()方法,傳遞新長度與原長度的比.
		}

		return this;		//返回按照引數l(長度)設定新的二維向量(x,y)值.

	},

	/*lerp方法
	///lerp方法在將當前二維向量(x,y)設定為下限和引數v(x,y)設為上限 之間進行線性插值，
	/// alpha 表示權值。從下限當前二維向量(x,y)到上限引數v(x,y)乘以百分比alpha(0.0-1.0),加上當前二維向量(x,y)
	///當前二維向量(x,y)的和賦值給當前二維向量(x,y),返回當前二維向量(x,y).
	/// NOTE:注意，如果 當前二維向量(x,y) 和 引數v(x,y)是向量，則權值 alpha 必須是標量,取值範圍是0.0-1.0.
	*/
	///<summary>lerp</summary>
	///<param name ="v" type="Vector2">二維向量</param>
	///<param name ="alpha" type="number">百分比權值(0.0-1.0)</param>
	///<returns type="Vector2">二維向量</returns>	
	lerp: function ( v, alpha ) {

		this.x += ( v.x - this.x ) * alpha;
		this.y += ( v.y - this.y ) * alpha;

		return this;	//返回二維向量

	},

	/*equals方法
	///equals方法相當於比較運算子===,將當前二維向量和引數v中的(x,y)值進行對比,返回bool型值.
	*/
	///<summary>equals</summary>
	///<param name ="v" type="Vector2">二維向量(x,y)</param>
	///<returns type="bool">返回true or false</returns
	equals: function ( v ) {

		return ( ( v.x === this.x ) && ( v.y === this.y ) );	//返回true or false

	},

	/*fromArray方法
	///fromArray方法將儲存二維向量(x,y)值的陣列賦值給當前二維向量物件
	*/
	///<summary>fromArray</summary>
	///<param name ="array" type="Array">二維向量(x,y)值陣列array[x,y]</param>
	///<returns type="Vector2">返回新的二維向量</returns>	
	fromArray: function ( array ) {

		this.x = array[ 0 ];
		this.y = array[ 1 ];

		return this;	//返回新的二維向量

	},

	/*toArray方法
	///toArray方法將當前二維向量物件的屬性賦值給陣列array[0.5,0.5].返回一個數組物件.
	*/
	///<summary>toArray</summary>
	///<returns type="Array">二維向量(x,y)值陣列array[x,y]</returns>	
	toArray: function () {

		return [ this.x, this.y ];	//二維向量(x,y)值陣列array[x,y]

	},

	/*clone方法
	///clone方法克隆一個二維向量物件.
	*/
	///<summary>clone</summary>
	///<returns type="Vector2">返回二維向量物件</returns>	
	clone: function () {

		return new THREE.Vector2( this.x, this.y );		//返回二維向量

	}

};