new Error( [message[, fileName[, lineNumber]]] ) : Error
new {Some}Error( [message[, fileName[, lineNumber]]] ) : {Some}Error
  {Some}Error = EvalError, RangeError, ReferenceError, SyntaxError, TypeError, URIError

エラーオブジェクトを返します。

function fun() {
  throw new Error("error-test!");
}

try{
  fun();
}catch(e){
  print("e instanceof Error => " + (e instanceof Error));
  print("message => " + e.message);
  print("name => " + e.name);
  print("lineNumber => " + e.lineNumber);
  print("fileName => " + e.fileName);
  print();
  print("stack => " + e.stack);
  print("to_string => " + e.toString());
  print("to_source => " + e.toSource());
}

/*
e instanceof Error => true
message => error-test!
name => Error
lineNumber => 2
fileName => D:\Work\t.js

stack => fun()@D:\Work\t.js:2
@D:\Work\t.js:6

to_string => Error: error-test!
to_source => (new Error("error-test!", "D:\\Work\\t.js", 2))
*/
  

toSource 関数 (非標準)Error...

error.toSource() : String

エラーオブジェクトのソース文字列を返します。

toString 関数 (非標準)Error...

error.toString() : String

エラーオブジェクトの文字列を返します。

var error = new Error("error-test!");
alert( error.toString() );  // Error: error-test!
alert( error.toSource() );  // (new Error("error-test!", "D:\\Work\\t.js", 33))

Function クラス ...

関数オブジェクトを扱うクラスです。

作成方法
Functionコンストラクター
  new Function ([arg1, arg2, ... argN,] functionBody)

function文(関数定義)
  function name([param1, param2, ... paramN]) {
     statements
  }


パラメーター

	

		
arg1, arg2, ... argN
		
関数の仮引数名。JavaScript変数に適合する文字列を与えます。例えば、"x" とか "theValue"
	
	

		
functionBody
		
関数定義に含まれるJavaScript文からなる文字列です。
	
	

		
name
		
関数名
	
	

		
param1, param2, ... paramN
		
関数に渡される引数の名前(仮引数)です。
	
	

		
statements
		
関数本体のJavaScript文です。
	



関数オブジェクトの呼び出し方
Functionコンストラクターの場合
  var sum = new Function("a","b","return a + b");
  alert( sum(20,30) ); // 50


function文(関数定義)の場合
  function sum(a,b) {
     return a + b;
  }
  alert( sum(200,300) ); // 500

arguments プロパティ JS1.0(非推奨)Function...

func.arguments : Array

function A(a,b,c)
{
 alert(A.arguments.length); // alert(arguments.length);
}

A(10); // 1

caller プロパティ JS1.5(非標準)Function...

func.caller : Function

function A(a,b,c)
{
	alert(A.caller.toSource() );
}
function B()
{
	A();
}

B();
/*
function B()
{
	A();
}
*/

constructor プロパティ JS1.1Function...

func.constructor : Object

function A() {}
alert( A.constructor==Function ); //true
 

length プロパティ JS1.1Function...

func.length : Integer [ReadOnly]

function A(a,b,c)
{
 alert(A.arguments.length); // alert(arguments.length);
}

A.length; // 3

name プロパティ (非標準)Function...

func.name : String

function A()
{
}
alert( A.name ); // "A"
 

Function コンストラクター JS1.1Function...

new Function([arg1, arg2, ... argN,] functionBody) : Function

関数の仮引数名

関数本体のJavaScript文

作成された関数オブジェクトを返します。

var multiply = new Function("x", "y", "return x * y");
alert( multiply(4,5) ); //20

apply 関数 JS1.3Function...

func.apply(thisArg[, argArray])

呼び出しオブジェクト

argArray[0],argArray[1],...が関数オブジェクトへ渡されます。

オブジェクトを指定しない呼び出し(call)の場合
    function sum(a,b) { return a + b; }
    alert( sum(20,30) ); // 50
    alert( sum.apply(null,[20,30]) ); // 50
  sum(20,30)とsum.apply(null,[20,30])は同じ呼び出しです。

オブジェクトを指定した呼び出し(call)の場合
    function Point(x,y) { this.x = x; this.y = y; } // Pointクラスのコンストラクター
    function absm(k) { return k * Math.sqrt(this.x*this.x + this.y*this.y); }
    Point.prototype.absm = absm;
    var pt = new Point(5,12);
    alert( pt.absm(2) ); // 26
    alert( absm.apply(pt,[2]) ); // 13
  pt.absm()とabsm.apply(pt,[2])は同じ呼び出しです。

bind 関数 JS1.8.5Function...

func.bind( thisArg[, arg1[, arg2[, ...]]] ) : Function

func1 = func.bind(null,p1,p2);
func1(a1,a2); // func(p1,p2,a1,a2); と同じ

func2 = func.bind(obj,p1,p2);
func2(a1,a2); // obj.func(p1,p2,a1,a2); と同じ

var x = 9,
    module = {
      getX: function() {
        return this.x;
      },
      x: 81
    };
 
//  module.getX() は, module==this となり, module.xが返ってきます。
print( module.getX() ); // 81
 
//  次の例では、thisにglobalオブジェクトがセットされています。
var getX = module.getX;
 
//  getX() は, module==global となり, xが返ってきます。
print( getX() );  // 9
 
//  以下では、moduleを thisとして結合されています。
var boundGetX = getX.bind(module);
 
//  boundGetX()は, this==module となり　module.xが返ってきます。
print( boundGetX() ); // 81

function List() {
  var a = [];
   
  for (var i = 0; i < arguments.length; i++) {
    
    a.push(arguments[i]);
   
  }
	       
  return a;
}
 
//  リスト作成
var listOne = List(1, 2, 3);
 
print(listOne); // [1, 2, 3]
 
 
//  1つの引数を取り込んだ関数を作成
var leadingZeroList = List.bind(null /* this */, 0);
 
print( leadingZeroList() ); // [0]
 
print( leadingZeroList(1) );  // [0, 1]
 
print( leadingZeroList(1, 2) ); // [0, 1, 2]

function Point(x, y) {
  this.x = x;
  this.y = y;
}
 
//  Pointコンストラクタのprototypeに toStringメソッドを追加
Point.prototype.toString = function() {
  return this.x + "," + this.y;
};
 
//  Pointコンストラクタでオブジェクトを作成
var p = new Point(1, 2);
 
print( p.toString() );  //  1,2
 
 
var emptyObj = {},
    YAxisPoint = Point.bind(emptyObj, 0 /* x */);
 
 
//  YAxisPointコンストラクタでオブジェクトを作成
var axisPoint = new YAxisPoint(5);
 
print( axisPoint.toString() );  // 0,5
 
print( axisPoint instanceof Point );  // true
 
print( new YAxisPoint(17) instanceof Point ); // true
 
print( new YAxisPoint(17) instanceof YAxisPoint );  // true
 
print( new Point(17, 42) instanceof YAxisPoint ); // true // 下記解説の完全でない実装では falseとなります。

// YAxisPointコンストラクタは普通の関数として呼び出せます。
YAxisPoint(13);
 
print( emptyObj.x + "," + emptyObj.y ); // 0,13

仮にJavaScriptに Function.prototype.bind 関数がない場合、完全でないけど次のように実装できます。

if ( !Function.prototype.bind ) {
  Function.prototype.bind = function( obj ) {
    var slice = [].slice,
        args = slice.call(arguments, 1),
        self = this,
        nop = function () {},
        bound = function () {
          return self.apply( this instanceof nop ? this : ( obj || {} ),
                              args.concat( slice.call(arguments) ) );   
        };
 
    nop.prototype = self.prototype;
 
    bound.prototype = new nop();
 
    return bound;
  };
}

この実装は、bindクラス関数の仕様といくらか違う動作をします。たとえば、上記の例3. 演算子instanceof が正しく動作していません。

call 関数 JS1.3Function...

func.call(thisArg[, arg1,arg2,...])

呼び出しオブジェクト

arg1, arg2, ...がそのまま関数オブジェクトへ渡されます。

オブジェクトを指定しない呼び出し(call)の場合
    function sum(a,b) { return a + b; }
    alert( sum(20,30) ); // 50
    alert( sum.call(null,20,30) ); // 50
  sum(20,30)とsum.call(null,20,30)は同じ呼び出しです。

オブジェクトを指定した呼び出し(call)の場合
    function Point(x,y) { this.x = x; this.y = y; } // Pointクラスのコンストラクター
    function absm(k) { return k * Math.sqrt(this.x*this.x + this.y*this.y); }
    Point.prototype.absm = absm;
    var pt = new Point(5,12);
    alert( pt.absm(2) ); // 26
    alert( absm.apply(pt,[2]) ); // 13
  pt.absm(2)とabsm.call(pt,2)は同じ呼び出しです。

toSource 関数 JS1.3(非標準)Function...

func.toSource() : String

関数のソースコードを文字列化して返します。

toString 関数 JS1.1Function...

func.toString() : String

関数のソースコードを文字列化して返します。

valueOf 関数 JS1.1Function...

func.valueOf() : String

funcを返します。

Number クラス ...

数値のラッパークラスです。

constructor プロパティ JS1.1Number...

number.constructor : Object

a = 12.3; // a = new Number(12.3);
alert( a.constructor==Number ); //true
 

MAX_VALUE 定数 JS1.0Number...

Number.MAX_VALUE : Number [ReadOnly]

JavaScriptが扱える最大数値を返します。約 1.79e+308
MAX_VALUEを超える数値はInfinityとされます。

MIN_VALUE 定数 JS1.0Number...

Number.MIN_VALUE : Number [ReadOnly]

JavaScriptが扱える最も0に近い正の数値を返します。約 5e-324
MIN_VALUEより小さい数値は0とされます。

NaN 定数 JS1.0Number...

Number.NaN [ReadOnly]

JavaScriptではNaNとリテラル表現されます。
NaN は、それ自身を含む、いかなる値と比較しても等しくなりません。isNaN 関数を使って調べれます。
数値を返す関数で、エラーが発生したときこの値を返すことで使用します。

NEGATIVE_INFINITY 定数 JS1.0Number...

Number.NEGATIVE_INFINITY : Number [ReadOnly]

-Infinityとリテラル表現されます。
JavaScript で表現できる最も小さい負の値 (-Number.MAX_VALUE) よりも小さい値はNumber.NEGATIVE_INFINITYとして扱います。

POSITIVE_INFINITY 定数 JS1.0Number...

Number.POSITIVE_INFINITY : Number [ReadOnly]

Infinityとリテラル表現されます。
JavaScript で表現できる最も大きい値 (Number.MAX_VALUE) よりも大きい値はNumber.POSITIVE_INFINITYとして扱います。

Number コンストラクター Number...

new Number(value) : Number

数値

作成された数値オブジェクトを返します。

数値からこのNumberクラスの関数を呼び出すとき、
このコンストラクターで自動的にNumberオブジェクトに変換してから呼び出します。

var a = 1234;
alert( a.toString(16) ); // 4d2

toExponential 関数 JS1.5Number...

number.toExponential([fractionDigits]) : String

小数点以下の桁数  省略した場合、数値の表現に必要な桁数がセットされます。

指数表記の数値を表す文字列を返します。

var num=77.1234
alert(num.toExponential())  // 7.71234e+1
alert(num.toExponential(4)) // 7.7123e+1   
alert(num.toExponential(2)) //displays 7.71e+1
alert(77.1234.toExponential()) // 7.71234e+1
alert(77 .toExponential())   // 7.7e+1 注意: .の前にスペースをあり！

toFixed 関数 JS1.5Number...

number.toFixed([fractionDigits]) : String

小数点以下の桁数  省略した場合、0桁

固定小数点表記の数値を表す文字列を返します。

var num=10.1234
alert(num.toFixed())  // 10
alert(num.toFixed(4)) // 10.1234
alert(num.toFixed(2)) // 10.12 

toLocaleString 関数Number...

number.toLocaleString() : String

数のローカライズした文字列を返します。

toPrecision 関数Number...

number.toPrecision([precision]) : String

有効桁数を指定します。1～21  省略した場合、toString()を実行します。

指数表記の数値では、(precision - 1) 桁を小数点以下の数値として返します。
固定小数点の数値では、precision 有効桁数分を返します。

var num=5.123456
alert(num.toPrecision())    // 5.123456
alert(num.toPrecision(4))   // 5.123
alert(num.toPrecision(2))   // 5.1
alert(num.toPrecision(1))   // 5
alert(1250 .toPrecision(2)) // 1.3e+3
alert(1250 .toPrecision(5)) // 1250.0 

toSource 関数 JS1.3 (非標準)Number...

number.toSource() : String

Numberオブジェクトのソース文字列を返します。

toString 関数 JS1.1Number...

number.toString([radix]) : String

進数を指定します。2～36  省略した場合、10

数値の文字列を返します。

JavaScriptは数値を文字列として表現しなければならないときや文字との連結のとき、
toString()が自動的に呼び出されます。

var howMany=10;
alert(howMany.toString());  // 10
alert(45 .toString());      // 45

valueOf 関数 JS1.1Number...

number.valueOf() : Number

格納されている数値を返します。

var x = new Number();
print(x.valueOf());     // 0

Object クラス ...

__proto__ プロパティ (非標準)Object...

object.__proto__ : Object

function Point(x,y) {
 this.x = x;
 this.y = y;
}

Point.prototype = {
 move : function(dx,dy) {
  this.x += dx;
  this.y += dy;
 },
 abs : function() {
  return Math.sqrt(this.x*this.x + this.y*this.y);
 }
};

var pnt = new Point(10,20);
alert( "pnt.x = "+pnt.x + "  pnt.y = "+pnt.y ); //pnt.x = 10  pnt.y = 20
alert( "pnt.abs() --> " + pnt.abs() ); //pnt.abs() --> 22.360679774997898

alert( pnt.__proto__==Point.prototype ); //true

constructor プロパティ JS1.1Object...

object.constructor : Object

o = new Object; // o = {}
alert( o.constructor == Object ); //true
a = new Array; // a = []
alert( a.constructor == Array ); // true
n = new Number(3);
alert( n.constructor == Number); // true

Object コンストラクター Object...

new Object() : Object

作成されたObjectオブジェクトを返します。

Objectオブジェクトの作成は、次のようにもできます。
  var obj = {}; // var obj = new Object();

プロパティ付きのObjectオブジェクト作成は、次のように書きます。
  var obj = { a:100, b:200 };
これは、以下と同じです。
  var obj = new Object();
  obj.a = 100; obj.b = 200;

create クラス関数 JS1.8.5Object...

Object.create( proto [, propertiesObject ] ) : Object

var o;

// point オブジェクトをプロトタイプとするオブジェクト作成
var point = { x:10, y:20};
o = Object.create(point);
print(o.x); // 10
o.y = 200;
print(o.y); // 200
print(point.y); // 20

// o = {} と同じ
o = Object.create(Object.prototype);

// プロトタイプ :新しい空オブジェクト
// プロパティは1つ p : 書き換え, 列挙, 構成変更 すべて不可
// which isn't writable, enumerable, or configurable
o = Object.create({}, { p: { value: 42 } });

defineProperty クラス関数 JS1.8.5Object...

Object.defineProperty( obj, prop, descriptor ) : Object

// 普通のプロパティ定義
var o = {};
o.p = 42;

// defineProperty関数を使ったプロパティ定義
var o = {};
Object.defineProperty(o, "p",
           {
              value : 42,
              writable : true,
              enumerable   : true,
              configurable : true
           }
);

// 普通のget setを使ったプロパティ定義
var o = {v : 1, get p() { return this.v; }, set p(x) { this.v = x; } };
o.p = 42;

// defineProperty関数を使ったプロパティ定義
var o = { v : 1 };
Object.defineProperty(o, "p",
           {
              get : function() { return this.v; },
              set : function(x) { this.v = x; },
              enumerable : true,
              configurable : true
           }
);
o.p = 42;

・writable 属性
var o = {}; // Creates a new object
Object.defineProperty(o, "a", {value : 37,
                               writable : false});

alert(o.a); // 37
o.a = 25;
alert(o.a); // 37. 代入は効かない。また エラーは throwされない

・enumerable 属性
var i;
var o = {};
Object.defineProperty(o, "a", { value : 1, enumerable:true });
Object.defineProperty(o, "b", { value : 2, enumerable:false });
Object.defineProperty(o, "c", { value : 3 }); // enumerable は defaults値 false
o.d = 4;

for (i in o) {   
  alert(i); 
}
// alerts 'a' then 'd'

・configurable 属性
var o = {};
Object.defineProperty(o, "a", { get : function(){return 1;},
	                                configurable : false } );

Object.defineProperty(o, "a", {configurable : true}); // TypeError: can't redefine non-configurable property 'a'
Object.defineProperty(o, "a", {enumerable : true}); // TypeError:  ...
Object.defineProperty(o, "a", {set : function(){}}); // TypeError: ...
Object.defineProperty(o, "a", {get : function(){return 1;}}); // TypeError: ...
Object.defineProperty(o, "a", {value : 12}); // TypeError: ...

alert(o.a); // 1
delete o.a; // プロパティ a は削除されない
alert(o.a); // 1

・普通のプロパティ追加と 属性がdefaultの場合 の違い
var o = {};

o.a = 1;
// これは次と同じ :
Object.defineProperty(o, "a", {value : 1,
                               writable : true,
                               configurable : true,
                               enumerable : true});

// 一方 :
Object.defineProperty(o, "a", {value : 1});
// これは以下と同じ :
Object.defineProperty(o, "a", {value : 1,
                               writable : false,
                               configurable : false,
                               enumerable : false});

defineProperties クラス関数 JS1.8.5Object...

Object.defineProperties( obj, props ) : Object

var point = { x : 1, y : 2 };

// これは次と同じ :
var point = {};
Object.defineProperties(point,
      { 
        x : {value : 1, writable : true, configurable : true, enumerable : true},
        y : {value : 2, writable : true, configurable : true, enumerable : true}
      }
);

freeze クラス関数 JS1.8.5Object...

Object.freeze( obj ) : Object

var obj =
  {
    prop: function () {},
    foo: "bar"      
  };   
 
// プロパティ追加、値変更、プロパティ削除ができます。
obj.foo = "baz";
obj.lumpy = "woof";
delete obj.prop;
 
// オブジェクトを凍結する
var o = Object.freeze(obj);
print(o === obj);	// true
 
print(Object.isFrozen(obj) === true);	// true
 
// 値変更やプロパティ追加は失敗します。
obj.foo = "quux"; // 値変更しない。何も文句を言わない。
obj.quaxxor = "the friendly duck"; // プロパティ追加はできていない。何も文句を言わない。
 
// つぎに strictモードで試すとTypeErrorをthrowします。
function fail()
{
  "use strict";
  obj.foo = "sparky"; // TypeError: obj.foo is read-only
  obj.sparky = "arf"; // TypeError: obj.sparky is not extensible
  delete obj.foo; // TypeError: property obj.foo is non-configurable and can't be deleted
}
fail();

// Object.definePropertyを使うと TypeErrorをthrowします。
Object.defineProperty(obj, "ohai", { value: 17 }); // TypeError: Object.defineProperty(..., ({value:17})) is not extensible
Object.defineProperty(obj, "foo", { value: "eit", writable: true }); // TypeError: can't redefine non-configurable property 'foo'

getOwnPropertyDescriptor クラス関数 JS1.8.5Object...

Object.getOwnPropertyDescriptor( obj, prop ) : Object

var o, d;
 
o = { get foo() { return 17; } };
d = Object.getOwnPropertyDescriptor(o, "foo");
print( uneval(d) );
/*
 {get: getter func, set: undefined, enumerable:true, configurable:true}
*/

o = { bar: 42 };
d = Object.getOwnPropertyDescriptor(o, "bar");
print( uneval(d) );
/*
 {value:42, writable:true, enumerable:true, configurable:true}
*/

o = {};
Object.defineProperty(o, "baz", { value: 8675309, writable: false, enumerable: false });
d = Object.getOwnPropertyDescriptor(o, "baz");
print( uneval(d) );
/*
 {value:8675309, writable:false, enumerable:false, configurable:false}
*/

getOwnPropertyNames クラス関数 JS1.8.5Object...

Object.getOwnPropertyNames( obj ) : Object

var arr = ["a", "b", "c"];
print(Object.getOwnPropertyNames(arr).sort()); // 0,1,2,length
 
// 配列のようなオブジェクト
var obj = { 0: "a", 1: "b", 2: "c"};
print(Object.getOwnPropertyNames(obj).sort()); // 0,1,2
 
// 列挙付加なプロパティ
var my_obj = Object.create({}, { getFoo: { value: function() { return this.foo; }, enumerable: false } });
my_obj.foo = 1;
 
print(Object.getOwnPropertyNames(my_obj).sort()); // foo,getFoo

getPrototypeOf クラス関数 JS1.8.1Object...

Object.getPrototypeOf( object ) : Object

function Foo() {}

obj = new Foo()
alert( Object.getPrototypeOf(obj)==obj.__proto__ ) // => true
alert( Object.getPrototypeOf(obj)==Foo.prototype ) // => true

hasOwnProperty 関数 Object...

object.hasOwnProperty( prop ) : Boolean

function Point(x,y) {
 this.x = x;
 this.y = y;
}

Point.prototype = {
 move : function(dx,dy) {
  this.x += dx;
  this.y += dy;
 },
};

var pnt = new Point(10,20);
alert( pnt.hasOwnProperty('x') ); //true
alert( pnt.hasOwnProperty('move') ); //false

isExtensibleクラス関数 Object...

Object.isExtensible( obj ) : Boolean

// 新規オブジェクトは 拡張可能(extensible)です。
var empty = {};
print(Object.isExtensible(empty));  // true

// 拡張禁止に変更すると...
Object.preventExtensions(empty);
print(Object.isExtensible(empty));  // false

// オブジェクトが保護されていれば、保護の意味から拡張禁止(non-extensible)となります。
var sealed = Object.seal({});
print(Object.isExtensible(sealed)); // false

// 凍結された オブジェクトは、凍結の意味から拡張禁止(non-extensible)となります。
var frozen = Object.freeze({});
print(Object.isExtensible(frozen)); // false

isFrozenクラス関数 Object...

Object.isFrozen( obj ) : Boolean

  ・extensibleでない
  ・自身のすべてのプロパティがconfigurable==false
  ・自身の data プロパティ すべてが writable==false
  ・自身の accessor プロパティ すべてが setter を持たない

// 新規オブジェクトは extensibleなので、それは 凍結状態ではありません。
print( Object.isFrozen({}) ); // false
 
// 空の non-extensibleオブジェクトは、無意味な凍結状態です。
var vacuouslyFrozen = Object.preventExtensions({});
print(Object.isFrozen(vacuouslyFrozen));  // true
 
// 1つだけのプロパティを持つ新規オブジェクトは extensibleです。したっがて 凍結状態でない。
var oneProp = { p: 42 };
print(Object.isFrozen(oneProp));  // false
 
// オブジェクトを拡張不可にしても それはまだ凍結状態にはならない。
// なぜかというと、まだ configurable かつ writable であるから。
Object.preventExtensions(oneProp);
print(Object.isFrozen(oneProp));  // false
 
// しかし そのプロパティをdeleteすると、無意味な凍結状態になります。
delete oneProp.p;
print(Object.isFrozen(oneProp));  // true
 
// non-writableでconfigurableなプロパティを持つ non-extensible オブジェクトは 凍結状態ではない。
var nonWritable = { e: "plep" };
Object.preventExtensions(nonWritable);
Object.defineProperty(nonWritable, "e", { writable: false }); // non-writableにする configurableはそのまま
print(Object.isFrozen(nonWritable));  // false
 
// プロパティをnon-configurable に変更したら、凍結状態になります。
Object.defineProperty(nonWritable, "e", { configurable: false }); // non-configurableにする
print(Object.isFrozen(nonWritable));  // true
 
// non-configurableでwritableなプロパティを持つ non-extensible オブジェクトは 凍結状態ではない。
var nonConfigurable = { release: "the kraken!" };
Object.preventExtensions(nonConfigurable);
Object.defineProperty(nonConfigurable, "release", { configurable: false });
print(Object.isFrozen(nonConfigurable));  // false
 
// プロパティをnon-writable に変更したら、凍結状態になります。
Object.defineProperty(nonConfigurable, "release", { writable: false });
print(Object.isFrozen(nonConfigurable));  // true
 
// configurable accessor プロパティを持つ拡張不可なオブジェクトは 凍結状態ではない。
var accessor = { get food() { return "yum"; } };
Object.preventExtensions(accessor);
print(Object.isFrozen(accessor)); // false
 
// しかし そのプロパティを non-configurable にすれば、凍結状態になります。
Object.defineProperty(accessor, "food", { configurable: false });
print(Object.isFrozen(accessor)); // true
 
// freezeスタティク関数を使えば、オブジェクトをもっと簡単に 凍結状態にできます。
var frozen = { 1: 81 };
print(Object.isFrozen(frozen)); // false
Object.freeze(frozen);
print(Object.isFrozen(frozen)); // true
 
// 凍結状態なので、 frozen オブジェクトは non-extensibleであります。
print(Object.isExtensible(frozen)); // false
 
// また同様に frozen オブジェクトは sealされています。
print(Object.isSealed(frozen)); // true

isPrototypeOf 関数 Object...

object.isPrototypeOf( obj ) : Boolean

function Foo() {}
function Bar() {}

obj = new Foo()
alert( Foo.prototype.isPrototypeOf(obj) ) // => true
alert( Bar.prototype.isPrototypeOf(obj) ) // => false

isSealedクラス関数 Object...

Object.isSealed( obj ) : Boolean

// defaultでは 保護されていない。
var empty = {};
print(Object.isSealed(empty));  // false
 
// 空の non-extensibleオブジェクトは、保護されている状態です。
Object.preventExtensions(empty);
print(Object.isSealed(empty));  // true
 
// 空でないオブジェクトのプロパティがすべてnon-configurableでなければ、保護されていない状態です。
var hasProp = { fee: "fie foe fum" };
Object.preventExtensions(hasProp);
print(Object.isSealed(hasProp));  // false
 
// しかし、プロパティをすべてnon-configurableにすれば、保護状態になります。
Object.defineProperty(hasProp, "fee", { configurable: false });
print(Object.isSealed(hasProp));  // true
 
// seal関数を使えば、最も簡単にオブジェクトを保護できます。
var sealed = {};
Object.seal(sealed);
print(Object.isSealed(sealed)); // true
 
// 保護されたオブジェクトはデフォルトで 拡張不可(non-extensible)になってます。
print(Object.isExtensible(sealed)); // false
 
// 保護されたオブジェクトは、凍結された状態かどうかは不定...
print(Object.isFrozen(sealed)); // true  プロパティがすべて non-writableだから
 
var s2 = Object.seal({ p: 3 });
print(Object.isFrozen(s2)); // false  "p" プロパティは writableだから
 
var s3 = Object.seal({ get p() { return 0; } });
print(Object.isFrozen(s3)); // true  accessorプロパティがgetterだけだから

keysクラス関数 Object...

Object.keys( obj ) : Array

if(!Object.keys) Object.keys = function(o){
  if (o !== Object(o))
    throw new TypeError('Object.keys called on non-object');
  var ret=[],p;
  for(p in o) if(Object.prototype.hasOwnProperty.call(o,p)) ret.push(p);
  return ret;
}

var arr = ["a", "b", "c"];
alert(Object.keys(arr)); // 0,1,2
 
// 配列ライクなオブジェクト
var obj = { 0 : "a", 1 : "b", 2 : "c"};
alert(Object.keys(obj)); // 0,1,2
 
// getFoo は　列挙不可なプロパティ
var my_obj = Object.create({}, { getFoo : { value : function () { return this.foo } } });
my_obj.foo = 1;
 
alert(Object.keys(my_obj)); // foo

preventExtensionsクラス関数 Object...

Object.preventExtensions( obj ) : Object

// preventExtensionsクラス関数は non-extensibleにしたオブジェクトを返します。
var obj = {};
var obj2 = Object.preventExtensions(obj);
print(obj === obj2);  // true
 
// defaultでは オブジェクトは extensible です。
var empty = {};
print(Object.isExtensible(empty));  // true
 
// 拡張禁止(non-extensible)に変更できます。
Object.preventExtensions(empty);
print(Object.isExtensible(empty)) // false
 
// non-extensibleなオブジェクトへ新しいプロパティを definePropertyクラス関数で追加すると TypeErrorが throwされます。
var nonExtensible = { removable: true };
Object.preventExtensions(nonExtensible);
Object.defineProperty(nonExtensible, "new", { value: 8675309 }); // throws a TypeError
 
// strict モードで、non-extensibleなオブジェクトへ新しいプロパティを代入で追加すると 同じくTypeErrorが throwされます。
function fail()
{
  "use strict";
  nonExtensible.newProperty = "FAIL"; // throws a TypeError
}
fail();
 
// non-extensible なオブジェクトの prototype は 変更できません。
var fixed = Object.preventExtensions({});
fixed.__proto__ = { oh: "hai" }; // throws a TypeError

propertyIsEnumerable 関数 Object...

object.propertyIsEnumerable( prop ) : Boolean

o = new Object();
a = new Array();
o.prop = 'is enumerable';
a[0] = 'is enumerable';

o.propertyIsEnumerable('prop');   // true を返す
a.propertyIsEnumerable(0);        // true を返す

a.propertyIsEnumerable('length'); // false を返す

sealクラス関数 Object...

Object.seal( obj ) : Object

var obj =
  {
    prop: function () {},
    foo: "bar"
  };
 
// 新規にプロパティを追加でき、存在しているプロパティは変更も削除もできます。
obj.foo = "baz";
obj.lumpy = "woof";
delete obj.prop;
 
var o = Object.seal(obj);
print(o === obj); // true
print(Object.isSealed(obj));  // true
 
// 保護されたオブジェクトのプロパティ値はまだ変更できます。
obj.foo = "quux";
 
// しかし、dataプロパティを accessorプロパティへ変換できません。その逆もできません。
Object.defineProperty(obj, "foo", { get: function() { return "g"; } }); // throws a TypeError
 
// 新規のプロパティ登録、プロパティ削除は失敗します。
obj.quaxxor = "the friendly duck"; // プロパティ登録に失敗しているが何も言わない。
delete obj.foo; // 同様に プロパティ削除に失敗しているが何も言わない。
 
// strictモードで 上記のことを実行させると TypeErrorがthrowされます。
function fail()
{
  "use strict";
  delete obj.foo; // throws a TypeError
  obj.sparky = "arf"; // throws a TypeError
}
fail();
 
// definePropertyクラス関数を使って 登録と変更を行っても TypeErrorがthrowされます。
Object.defineProperty(obj, "ohai", { value: 17 });   // throws a TypeError
Object.defineProperty(obj, "foo", { value: "eit" }); // doesn't throw a TypeError

toLocaleString 関数 Object...

object.toLocaleString() : String Object...

toSource 関数 JS1.3 (非標準)Object...

object.toSource( prop ) : String

オブジェクトのソースコード文字列を返します。

組み込みクラスについて toSource()関数が定義してあれば、それぞれ固有の形式で文字列を返してきます。
  例えば
     var a = new Array("A","B","C");
     alert( a.toSource() );  // ["A","B","C"]
     
     var func = new Function("a","b", "return a + b;");
     alert( func.toSource() );  //(function anonymous(a, b) {return a + b;})

そのほかのクラスから作成されたオブジェクトでは、プロパティとその値を列挙した形式で文字列化されます。
  例えば
     var a = { a : 100, b : 200 };
     alert( a.toSource() );  // ({a:100, b:200})
     
     function Point( x, y )
     {
        this.x = x; this.y = y;
     }
     var pt = new Point(5,12);
     alert( pt.toSource() );  // ({x:5, y:12})

toString 関数 JS1.0Object...

object.toString() : String

オブジェクトの値を表す文字列をを返します。

オブジェクトを文字列として表現したり、文字列と連結する必要があった場合、JavaScriptエンジンは
自動的にこのtoString()関数を呼び出します。
例えば、次の例ではtheDogは文字列化するが必要があります。
  print( theDog );
  print( "The dog is " + theDog );

デフォルトではObjectクラスから継承したオブジェクトはすべてtoString()を継承しています。
それらのtoString()関数は [object type]のような単純な文字列を返します。type はクラス名やコンストラクター関数の名前で
あったりします。
  例えば
  var o = new Object();
  alert( o.toString() );  // [object Object]

toString関数は、overrideできます。

組み込みクラスのtoString()関数.
toString()が呼ばれたとき、オブジェクトにあった文字列化を返すようにoverrideしてます。

デフォルト toString()関数のoverrideの仕方. 
ユーザークラス Dog を例にして、toString()関数をoverrideしてみましょう。

  function Dog(name,breed,color,sex) {
     this.name=name
     this.breed=breed
     this.color=color
     this.sex=sex
  }
  theDog = new Dog("Gabby","Lab","chocolate","girl") 
  
  //ここまでなら
  alert( theDog.toString() );  // [object Object]

  function dogToString() {
     var ret = "Dog " + this.name + " is [\n"
     for (var prop in this){
        if( ! (this[prop]  instanceof Function) )
            ret += " " + prop + " is " + this[prop] + ";\n"
     }
     return ret + "]"
  }

  // DogクラスのtoString関数をdogToString関数でoverrideします。
  Dog.prototype.toString = dogToString;

  //override後のtoString関数を実行
  alert( theDog.toString() );
  // 出力結果
  //   Dog Gabby is [
  //    name is Gabby;
  //    breed is Lab;
  //    color is chocolate;
  //    sex is girl;
  //   ] 

unwatch 関数 JS1.2 (非標準)Object...

object.unwatch(prop)

プロパティ名

watch関数で登録したプロパティの代入監視関数を削除します。

valueOf 関数 JS1.1Object...

object.valueOf()

デフォルトでは 自分自身(呼び出したオブジェクト) を返します。
オブジェクトのクラスがvalueOf関数をoverrideしていれば、それに応じた値を返します。

JavaScriptエンジンは、オブジェクトの基本データを必要となったとき自動的にvalueOf関数を呼び出します。
もちろん明示的に呼び出せます。
必要に応じて、クラスのvalueOf関数をoverrideできます。toString関数のoverride方法と同じです。

watch 関数 JS1.2 (非標準)Object...

object.watch(prop, handler)

プロパティ名

handelerは監視する関数を指定します。次の形式の関数です。
function handler(prop,oldval,newval)
{
   // prop : プロパティ名
   // oldval : prop の代入前の値
   // newval : 代入される新しい値
      ・
   // 処理
   return propの新しい値; //通常は return newval;
}

登録した代入監視関数を削除するには、unwatch関数を使います。
funcの解説をします。

o = {p:1}
o.watch("p",
   function (id,oldval,newval) {
      alert("o." + id + " changed from " 
         + oldval + " to " + newval)
      return newval
   }) 

o.p = 2;   // o.p changed from 1 to 2
o.p = 3    // o.p changed from 2 to 3
delete o.p
o.p = 4    // o.p changed from undefined to 4

o.unwatch('p')
o.p = 5    // 

__defineGetter__ 関数 (非標準)Object...

object.__defineGetter__( prop, getter)

var d = Date.prototype;
d.__defineGetter__("year", function() { return this.getFullYear(); });
d.__defineSetter__("year", function(y) { this.setFullYear(y); });

var now = new Date;
print(now.year); //get ==> 2008

now.year=2010;     //set ==>
print(now);        //Thu Mar 04 2010 15:54:04 GMT+0900

__defineSetter__ 関数 (非標準)Object...

object.__defineSetter__( prop, setter)

__lookupGetter__ 関数 (非標準)Object...

object.__lookupGetter__( prop ) : Function

__lookupSetter__ 関数 (非標準)Object...

object.__lookupSetter__( prop ) : Function

Proxy クラス JS1.8.5 (非標準) ...

      Proxy(日本語)解説
      Proxy(英語)解説
    

  ・ プロパティアクセス(代入、取得)
  ・ プロパティの属性変更
  ・in 演算子の適用
  ・delete 演算子の適用
  ・関数呼出、コンストラクター(F()、new F())

var userobj = Proxy.create({
  get: function(recvr, name) { return "Hello " + name + "!"; }
});

alert( userobj.JavaScript );  // Hello JavaScript!
alert( userobj.ECMAScript );  // Hello ECMAScript!

var Logging = "";
function simpleLogging( target, myname ) {
  var handler = {
    get: function(recvr,name) {
      Logging += myname + ": get( " + name + " )\n";
      return target[name];
    },
    set: function(recvr,name,val) {
      Logging += myname + ": set( " + name + ", " + val + " )\n";
      target[name] = val;
      return true;
    },
    delete: function(name) {
      Logging += myname + ": delete( " + name + " )\n";
			delete target[name];
      return true;
    }
  };

  return Proxy.create(handler);
}

var pnt1 = { x:0, y:0 }, pnt2 = { x:10, y:20, z:30 };
var pnt1L = simpleLogging( pnt1, "pnt-1" );
var pnt2L = simpleLogging( pnt2, "pnt-2" );

pnt1L.x = 100;
pnt2L.y = -pnt1L.x;
delete pnt2L.z;

print(Logging);
/*
pnt-1: set( x, 100 )
pnt-1: get( x )
pnt-2: set( y, -100 )
pnt-2: delete( z )
*/

print( uneval(pnt2) );	// ({x:10, y:-100, z:30})

function(name) {
  return !!this.getPropertyDescriptor(name);
}

function(name) {
  return !!this.getOwnPropertyDescriptor(name);
}

function(receiver, name) {
  var desc = this.getPropertyDescriptor(name);
  if (desc === undefined) { return undefined; }
  if ('value' in desc) {
    return desc.value;
  } else {
    if (desc.get === undefined) {
      return undefined;
    }
    return desc.get.call(receiver);
  }
}

function(receiver, name, val) {
  var desc = this.getOwnPropertyDescriptor(name);
  if (desc) {
    if ('writable' in desc) {
      if (desc.writable) {
        desc.value = val;
        this.defineProperty(name, desc);
        return true;
      } else {
        return false;
      }
    } else { // accessor
      if (desc.set) {
        desc.set.call(receiver, val);
        return true;
      } else {
        return false;
      }
    }
  }
  desc = this.getPropertyDescriptor(name);
  if (desc) {
    if ('writable' in desc) {
      if (desc.writable) {
        // fall through
      } else {
        return false;
      }
    } else { // accessor
      if (desc.set) {
        desc.set.call(receiver, val);
        return true;
      } else {
        return false;
      }
    }
  }
  this.defineProperty(name, {
    value: val, 
    writable: true, 
    enumerable: true, 
    configurable: true});
  return true;
}

function() {
  return this.getPropertyNames().filter(
    function (name) {
      return this.getPropertyDescriptor(name).enumerable
    } );
}

function() {
  return this.getOwnPropertyNames().filter(
    function (name) {
      return this.getOwnPropertyDescriptor(name).enumerable
    });
}

create 関数 JS1.8.5Proxy...

proxy = Proxy.create( handler[, proto] ) : Proxy

// 1. Simple logging
var Logging = "";
function simpleLogging( target, myname ) {
  var handler = {
    get: function(recvr,name) {
      Logging += myname + ": get( " + name + " )\n";
      return target[name];
    },
    set: function(recvr,name,val) {
      Logging += myname + ": set( " + name + ", " + val + " )\n";
      target[name] = val;
      return true;
    }
  };

  return Proxy.create(handler, Object.getPrototypeOf(target));
}

function Point(x,y) {
  this.x = x;
  this.y = y;
};
Point.prototype.abs = function () {
  return Math.sqrt(this.x*this.x + this.y*this.y);
}

var pnt = new Point(0,4);
var pntL = simpleLogging( pnt, "pnt" );

pntL.x = 3;
print(pntL.abs());	// 5

print(Logging);
/*
pnt: set( x, 3 )
pnt: get( abs )
pnt: get( x )
pnt: get( x )
pnt: get( y )
pnt: get( y )
*/

print( pnt instanceof Point ); //true
print( pntL instanceof Point ); //true

print( "x" in pnt ); //true
print( "x" in pntL ); //TypeError: getPropertyDescriptor is not a function

Logging = ""; // clear logs


// 2. Complete logging
// 参照：ForwardingHandlerのソース
ForwardingHandler(target) {
  this.target = target;
}
ForwardingHandler.prototype = {
  // Object.getOwnPropertyDescriptor(proxy, name) -> pd | undefined
  getOwnPropertyDescriptor: function(name) {
    var desc = Object.getOwnPropertyDescriptor(this.target, name);
    if (desc !== undefined) { desc.configurable = true; }
    return desc;
  },
  
  //.....
};

Proxy.Handler = ForwardingHandler;

//-------------------------------------
function makeLogging( target, myname ) {
  var handler = new Proxy.Handler(target);
  handler.get = function(recvr,name) {
      Logging += myname + ": get( " + name + " )\n";
      return target[name];
    };
  handler.set = function(recvr,name,val) {
      Logging += myname + ": set( " + name + ", " + val + " )\n";
      target[name] = val;
      return true;
    }
  };

  return Proxy.create(handler, Object.getPrototypeOf(target));
}

var Logging = "";
function makeLogging( target, myname ) {
  var handler = new Proxy.Handler(target);
  handler.get = function(recvr,name) {
      Logging += myname + ": get( " + name + " )\n";
      return target[name];
    };
  handler.set = function(recvr,name,val) {
      Logging += myname + ": set( " + name + ", " + val + " )\n";
      target[name] = val;
      return true;
    };

  return Proxy.create(handler, Object.getPrototypeOf(target));
}

function Point(x,y) {
  this.x = x;
  this.y = y;
};
Point.prototype.abs = function () {
  return Math.sqrt(this.x*this.x + this.y*this.y);
}

var pnt = new Point(0,4);
var pntL = makeLogging( pnt, "pnt" );

pntL.x = 3;
print(pntL.abs());	// 5

print(Logging);
/*
pnt: set( x, 3 )
pnt: get( abs )
pnt: get( x )
pnt: get( x )
pnt: get( y )
pnt: get( y )
*/

print( pnt instanceof Point ); //true
print( pntL instanceof Point ); //true

print( "x" in pnt ); //true
print( "x" in pntL ); //true !

var simpleHandler = {
  get: function(proxy, name) {
    // can intercept access to the 'prototype' of the function
    if (name === 'prototype') return Object.prototype;
    return 'Hello, '+ name;
  }
};
var fproxy = Proxy.createFunction(
  simpleHandler,
  function() { return arguments[0]; }, // call trap
  function() { return arguments[1]; }); // construct trap
  
print( fproxy(1,2) ); // 1
print( new fproxy(1,2) ); // 2
print( fproxy.prototype==Object.prototype); // true
print( fproxy.foo ); // 'Hello, foo'

RegExpは正規表現パターンを扱うクラスです。
検索に必要なプロパティや関数を揃えています。

作成方法
リテラル形式
  /pattern/flags
コンストラクター
  new RegExp( "pattern"[, "flags"] )


パラメーター

	

		
pattern
		
正規表現テキスト
	
	

		
flags
		
指定がある場合は以下の文字を組み合わせます。
			
g : pattern に指定したパターンと一致する文字列をすべて検索するグローバル検索
			
i : 大文字小文字を区別しない
			
m : 複数行検索
			
y : 対象文字列中の正規表現の lastIndex プロパティによって示された位置からのみマッチするようになります
	

例.
  /ab+c/i
  new RegExp("ab+c", "i") 

解説
正規表現パターンのテキストには \ を使いますのでコンストラクターを使う場合、エスケープ規則(\xx)が必要になります。
例えば、
  re = new RegExp("\\w+")
  re = /\w+/

正規表現で使われる特殊文字のリストテーブルを以下に記述します。
これらを組み合わせて、正規表現パターンを作成します。

Table 1.1正規表現での特殊文字

	

		
文字
意味
	
	

		
\
		
\の後に英数字が続くと正規表現の特殊文字となりえます。
\の後に\,^,$, ... などの特殊文字を表す文字がが現れた場合には本来の文字に解釈されます。
例えば /a*/ は a が0個以上続いた文字列と一致しますが、/a\*/ では 'a*' と一致します。
	
	

		
^
		
入力文字列の先頭と一致します。m フラッグが設定されている場合、^ は '\n' または '\r' の直後にも一致します。
	
	

		
$
		
入力文字列の末尾と一致します。m フラッグが設定されている場合、$ は '\n' または '\r' の直前にも一致します。
	
	

		
*
		
直前の項目と 0 回以上一致します。たとえば、"zo*" は "z" とも "zoo" とも一致します。* は {0,} と同じ意味になります。
	
	

		
+
		
直前の項目と 1 回以上一致します。たとえば、"zo+" は "zo" や "zoo" とは一致しますが、"z" とは一致しません。+ は {1,} と同じ意味になります。
	
	

		
?
		
直前の項目と 0 回または 1 回一致します。たとえば、"do(es)?" は "do" または "does" の"do" と一致します。? は {0,1} と同じ意味になります。
	
	

		
.
		
"\n" を除く任意の 1 文字に一致します。'\n' など、任意の文字と一致するには、'[\s\S]' などのパターンを指定します。
	
	

		
(x)
		
パターンxと一致し、文字列を記憶します。たとえば、/(foo)/ は "foo bar." の "foo" と一致し記憶されます。
		それは,配列結果の [1], ..., [n] や RegExp.$1, ..., RegExp.$9 で取り出します。
	
	

		
(?:x)
		
パターンxと一致しても、その文字列は記憶されず、後で使用することはできません。
	
	

		
x(?=y)
		
x の後に y が一致したとき x と一致します。(?=y)と一致した部分は記憶されません。
	
	

		
x(?!y)
		
x の後に y と一致しなかったときのみ x と一致します。(?!y)の部分は記憶されません。
	
	

		
x|y
		
x または y と一致します。たとえば、'z|food' は "z" または "food" と一致します。"(z|f)ood" は "zoo" または "food" に一致します。
	
	

		
{n}
		
n には 0 以上の整数を指定します。正確に n 回一致します。たとえば、'o{2}' は "Bob" の 'o' とは一致しませんが、"food" の 2 つの o とは一致します。
	
	

		
{n,}
		
n には 0 以上の整数を指定します。少なくとも n 回一致します。たとえば、'o{2}' は "Bob" の "o" とは一致しませんが、"foooood" のすべての o とは一致します。'o{1,}' は 'o+' と同じ意味になります。'o{0,}' は 'o*' と同じ意味になります。
	
	

		
{n,m}
		
m および n には 0 以上の整数を指定します。n は m 以下です。n ～ m 回一致します。たとえば、"o{1,3}" は "fooooood" の最初の 3 つの o と一致します。'o{0,1}' は 'o?' と同じ意味になります。
	
	

		
[xyz]
		
文字セットを指定します。角かっこで囲まれた文字の中のいずれかに一致します。たとえば、'[abc]' は "plain" の 'a' と一致します。
	
	

		
[^xyz]
		
除外する文字セットを指定します。角かっこで囲まれた文字以外の文字に一致します。たとえば、'[^abc]' は "plain" の 'p' と一致します。
	
	

		
[\b]
		
バックスペースと一致します。
	
	

		
\b
		
単語の境界と一致します。単語の境界とは、単語とスペースとの間の位置のことです。たとえば、'er\b' は "never" の 'er' と一致しますが、"verb" の 'er' とは一致しません。
	
	

		
\B
		
単語境界以外と一致します。たとえば、'er\B' は "verb" の 'er' と一致しますが、"never" の 'er' とは一致しません。
	
	

		
\cX
		
x で指定した制御文字と一致します。たとえば、\cM は Control-M またはキャリッジ リターン文字と一致します。x の値は、A-Z または a-z の範囲内で指定します。それ以外を指定すると、リテラル文字 "c" と認識されます。
	
	

		
\d
		
任意の 10 進文字と一致します。[0-9] と同じ意味になります。
	
	

		
\D
		
10 進数字以外の任意の 1 文字と一致します。[^0-9] と同じ意味になります。
	
	

		
\f
		
フォームフィード文字と一致します。\x0c および \cL と同じ意味になります。
	
	

		
\n
		
改行文字と一致します。\x0a および \cJ と同じ意味になります。
	
	

		
\r
		
キャリッジ リターン文字と一致します。\x0d および \cM と同じ意味になります。
	
	

		
\s
		
スペース、タブ、フォームフィードなどの任意の空白文字と一致します。[ \f\n\r\t\v] と同じ意味になります。
	
	

		
\S
		
空白文字以外の任意の文字と一致します。[^ \f\n\r\t\v] と同じ意味になります。
	
	

		
\t
		
タブ文字と一致します。\x09 および \cI と同じ意味になります。
	
	

		
\v
		
垂直タブ文字と一致します。\x0b および \cK と同じ意味になります。
	
	

		
\w
		
単語に使用される任意の文字と一致します。アンダースコアも含まれます。'[A-Za-z0-9_]' と同じ意味になります。
	
	

		
\W
		
単語に使用される文字以外の任意の文字と一致します。'[^A-Za-z0-9_]' と同じ意味になります。
	
	

		
\num
		
num には正の整数を指定します。既に見つかって記憶されている部分と一致します。たとえば、'(.)\1' は、連続する 2 つの同じ文字と一致します。
	
	

		
\0
		
ヌル文字と一致します。
	
	

		
\xhh
		
ASCII 文字を表した 2 桁の 16 進数を指定します。
	
	

		
\u	hhhh
		
Unicode 文字で表した 4 桁の 16 進数を指定します。
	
	

a = /ab+c/i; // a = new RegExp("ab+c", "i") 
alert( a.constructor==RegExp ); //true
 

正規表現にフラッグ g が使われていれば trueを返し、使われていなければ falseを返します。
正規表現にフラッグ g が使われていれば 検索文字列内のパターンの最初の 1 候補だけではなく、
すべての候補を検索できます。

正規表現にフラッグ i が使われていれば trueを返し、使われていなければ falseを返します。
正規表現にフラッグ i が使われていれば 検索で大文字小文字を区別しません。

  lastIndexOfプロパティは、正規表現が、グローバルサーチを示す"g" を使用した場合にのみ、セットされます。

exec関数で実行結果が返ったとき,その一致した文字列の次位置がセットされます。
exec関数を再度実行すると次の位置から検索を開始します。
lastIndexの値を変更すれば検索開始位置をコントロールできます。

正規表現にフラッグ m が使われていれば trueを返し、使われていなければ falseを返します。
multiline が false のとき、"^" で文字列の先頭位置に一致し、"$" で文字列の最終位置に一致します。
multiline が true のとき、"^"で、"\n" または "\r" の直後を含む文字列の先頭位置に一致し、"$" で、"\n" または "\r" の直前を含む文字列の最終位置に一致します。

正規表現から / とフラッグを除いたテキストを返します。

正規表現テキスト Table 1.1正規表現での特殊文字

以下の文字を組み合わせた文字列を与えます。
g : pattern に指定したパターンと一致する文字列をすべて検索するグローバル検索
i : 大文字小文字を区別しない
m : 複数行検索
y : 対象文字列中の正規表現の lastIndex プロパティによって示された位置からのみマッチするようになります

作成されたRegExpオブジェクトを返します。

リテラル形式で RegExpオブジェクトを作成することもできます。
  /pattern/flags
ここでのpattern, flagsは文字列の前後に置く " , '  を除いてます。また正規表現での特殊文字 \xx は素直に使えます。
コンストラクターの引数 pattern は、通常の文字列なので \\xx と \を２つ続けて記述する必要があります。
また、コンストラクターの引数 pattern, flags は,文字列なので、ダイナミックに変更できるRegExpオブジェクトを
作成できます。

/ab+c/i
new RegExp("ab+c", "i") 

正規表現テキスト Table 1.1正規表現での特殊文字

var reg = new RegExp("abc");
alert( reg.test("xyz abc") ); // true
alert( reg.test("xyz 123") ); // false

reg.compile("123");
alert( reg.test("xyz abc") ); // false
alert( reg.test("xyz 123") ); // true

検索対象とする文字列

パターンに一致する文字列が見つからなかった場合、exec メソッドは null を返します。
検索結果を含む配列を返します。
返された配列の内容は、例で説明します。

   myRe=/d(b+)(d)/ig;
   myArray = myRe.exec("cdbBdbsbz");

myArray

	

		
プロパティ/インデックス
  
説明
  
値
	
	

		

		
配列の中身
["dbBd", "bB", "d"]
	
	

		
index
		
一致した位置
1
	
	

		
input
検索対象文字列
cdbBdbsbz
	
	

		
[0]
最後に一致した文字列
dbBd
	
	

		
[1], ..., [n]
		
正規表現パターン内の(...)に一致したサブ文字列が格納されます。
		
[1] = bB [2] = d 
	
	
myRe.lastIndex は 5 に更新されて一致した文字列の次の位置がセットされます。
つぎの検索位置がセットされます。
再度
  myArray = myRe.exec("cdbBdbsbz");
を実行するとつぎの一致位置を見つけてくれます。

検索対象となる文字列を指定します。

文字列内にパターンに一致する部分があれば trueを返し、なければ falseを返します。

ただ単にパターンに一致する部分があるかどうかなら,test関数を使います。(Stringクラスのsearch関数も同じ)
もっと一致した詳しい情報を取得したい場合には exec関数を利用してください。(Stringクラスのmatch関数も同じ)

function testinput(re, str){
   if (re.test(str))
      laststring = " を含みます。";
   else
      laststring = " を含みません。";
   alert(str + " は " + re.source + laststring );
}

testinput( /pen|chopstick/, "This is a pen." );  // This is a pen. は pen|chopstick を含みます。

RegExpオブジェクトのリテラル表示を文字列にして返します。

toString関数と同じです。

var re = new RegExp("ab+c", "i");
alert( re.toSource() );  ///ab+c/i

RegExpオブジェクトのリテラル表示を文字列にして返します。

toSource関数と同じです。

var re = new RegExp("ab+c", "i");
alert( re.toString() );  // ab+c/i

文字列のラッパークラスです。

文字列(リテラル)と文字列オブジェクトとは違います。
  s1 = "foo";             // 文字列(リテラル)データ作成
  s2 = new String("foo"); // 文字列オブジェクト作成

文字列(リテラル)データは文字列オブジェクトの関数が直接使えます。
これは、JavaScriptが内部で自動的に文字列オブジェクトに変換してから関数を呼び出し、一時的に作成
されたその文字列オブジェクトは削除されます。

a = "abc"; // a = new String("abc");
alert( a.constructor==String ); //true
 

文字列の長さを返します。

var x = "ABCDEFG";
var japanese = "日本語";
alert( x.length );   // 7
alert( japanese.length ); //3

i は、0 から length - 1 までの正の整数です。このプロパティは読み込み専用です。

var x = "ABCDEFG";
alert( x[5] );   // F

文字列

作成された文字列オブジェクトを返します。

0～文字の長さ-1

先頭からindex番目の文字を返します。先頭はindex=0
indexが0～文字の長さ-1外なら空文字列を返します。

var anyString="0123あいう";
alert(anyString.charAt(2));  // 2
alert(anyString.charAt(5));  // い

0～文字の長さ-1  デファオルトは0

先頭からindex番目の文字コード(Unicode)を返します。先頭はindex=0
Unicode値 0～128はASCIIコードと一致しています。

funcの解説をします。

alert( "ABC".charCodeAt(0) ); // 65

連結される文字列

連結した文字列を返します。

funcの解説をします。

s1="Oh ";
s2="what a beautiful ";
s3="mornin'.";
s4=s1.concat(s2,s3);
alert(s4); // "Oh what a beautiful mornin'." 

Unicode列

Unicode列から生成された文字列を返します。

funcの解説をします。

alert( String.fromCharCode(65,66,67) );  // "ABC"

String オブジェクト内で検索する文字列

検索開始位置 0～文字列長さ-1  省略した場合、文字列の先頭から検索が開始されます。

String オブジェクト内で見つかった検索文字列の先頭位置を返します。
見つからなければ-1を返します。

"Blue Whale".indexOf("Blue")    // 0
"Blue Whale".indexOf("Blute")   // -1
"Blue Whale".indexOf("Whale",0) // 5
"Blue Whale".indexOf("Whale",5) // 5
"Blue Whale".indexOf("",9)      // 9
"Blue Whale".indexOf("",10)     // 10
"Blue Whale".indexOf("",11)     // 10 

"Blue Whale".indexOf("blue") // -1 大文字・小文字は区別

String オブジェクト内で検索する文字列

検索開始位置 0～文字列長さ-1  省略した場合、文字列の末尾から検索が開始されます。

String オブジェクト内で見つかった検索文字列の先頭位置を返します。
見つからなければ-1を返します。

"canal".lastIndexOf("a")   // 3
"canal".lastIndexOf("a",2) // 1
"canal".lastIndexOf("a",0) // -1
"canal".lastIndexOf("x")   // -1 

"Blue Whale, Killer Whale".lastIndexOf("blue") // -1  大文字・小文字は区別

var anyString="Brave new world" 
anyString.lastIndexOf("new") //6
anyString.indexOf("new") //6

"JavaScript".localeCompare("javascript"); //-32
"JavaScript".localeCompare("javascript"); // 0
"javascript".localeCompare("JavaScript"); //32

正規表現パターンおよびフラグを含む RegExpオブジェクトを指定します。文字列を指定することもできます。
regexp がRegExpオブジェクトでない場合は文字列に変換して、完全に一致する文字列の検索が実行されます。

パターンに一致する文字列が見つからなかった場合、null を返します。
一致する文字列が見つかった場合は、結果を配列にセットして返します。

regexpにグローバル フラグ (g) が設定されていない場合、RegExpオブジェクト.exec(..)と同じ結果が返ってきます。
0 に一致したサブ文字列がセットされ、1～n-1には正規表現内の(..)に対応したサブ文字列がセットされます。
regexpにグローバル フラグ (g) が設定されている場合、要素 0 から n-1 には検出されたすべての一致がそれぞれセットされます。
n は、返してきた配列の長さです。

ss = "cdbBdbsbz dbd";
myRe=/d(b+)(d)/i;
myArray = ss.match(myRe);
alert( myArray );  // dbBd,bB,d

ss = "cdbBdbsbz dbd";
myRe=/d(b+)(d)/ig;
myArray = ss.match(myRe);
alert( myArray );  // dbBd,dbd

正規表現パターンおよびフラグを含む RegExpオブジェクトを指定します。文字列を指定することもできます。
regexp がRegExpオブジェクトでない場合は文字列に変換して、完全に一致する文字列の検索が実行されます。

検索で見つかった部分を置換する文字列を指定します。
この文字列内に $x を含めて加工した文字列置換を行なえます。解説を参照してください。

regexpと一致するサブ文字列が見つかったとき呼び出される関数を指定します。
一致したサブ文字列をこの関数が返した文字列で置換します。
この関数の仕様は以下のとうりです。
function func( substr, m1, ..., mN, pos, text )
{
  // substr : 一致したサブ文字列
  // m1, ..., mN : regexp の中で使用されている開き括弧に対応した検索結果
  // pos : 一致位置
  // text : この関数を呼び出した文字列オブジェクトの文字列
       ・
  // 処理
  return 置換文字列;
}

呼び出した文字列オブジェクトの文字列を正規表現または検索文字列を使って置換した文字列のコピーを返します。

引数newSubStrの文字列内で使える $x は、置換処理を動的に行なえます。$x は以下の文字列置換を行ないます。

	

		
$$
		
$ に置き換えます。
	
	

		
$&
		
一致したサブ文字列を置き換えます。
	
	

		
$`
		
一致したサブ文字列の前の部分の文字列を置き換えます。
	
	

		
$'
		
一致したサブ文字列の後の部分の文字列を置き換えます。
	
	

		
$n
		
n は0～99までの整数。n 番目の(..)に対応した文字列を置き換えます。
	
	

// regexpを文字列とした場合
s = "This is a pen. This is a box.";
alert( s.replace("This","That") );  // That is a pen. This is a box.

// regexpに gi フラッグをつけた場合
re = /apples/gi;
str = "Apples are round, and apples are juicy.";
newstr=str.replace(re, "oranges");
alert(newstr);   // oranges are round, and oranges are juicy.

// 置換文字列で $x を使用した場合
ss = "The rain in Spain falls mainly in the plain.";
re = /(\S+)(\s+)(\S+)/g;
r = ss.replace(re, "$3$2$1");
alert( r );   // rain The Spain in mainly falls the in plain.

// 置換関数を第二引数値とした場合
function replaceFunc( substr, m1, pos, text )
{
  return (((m1 - 32) * 5/9) + "C");
}
ss = "Water freezes at 32F and boils at 212F.";
re = /(\d+(\.\d*)?)F\b/g;
r = ss.replace( re, replaceFunc );
alert( r );   // Water freezes at 0C and boils at 100C.

正規表現パターンおよびフラグを含む RegExpオブジェクトを指定します。文字列を指定することもできます。
regexp がRegExpオブジェクトでない場合は文字列に変換して、完全に一致する文字列の検索が実行されます。

一致する文字列が見つかった場合、その位置を返します。位置は0～です。
一致する文字列が見つからなかった場合は、-1 を返します。

ss = "ABCDEFG";
// Match !
if (ss.search(/def/i) != -1) {
    alert("Match");
}
// No match !
if (ss.search("def") != -1) {
    alert("Match");
}

start から end の前の文字までを含む文字列を返します。

start < 0 なら, (文字列長さ - start) とします。
end > 文字列長さ なら, end = 文字列長さとします。
end < 0 なら, end は (文字列長さ - end) とします。
start >= end なら, 空文字列を返します。
 

var anyString="abcdefgh" 

// "abc"
print(anyString.slice(0,3));

// "efg"
print(anyString.slice(4,7));

// "efgh"
print(anyString.slice(4));

// "abcdefgh"
print(anyString.slice(0,10)) 
print(anyString.slice(0));
print(anyString.slice());

// "adef"
print(anyString.slice(3,-2));

配列に返される要素の数を制限する値を指定します。 

var s = "abcd efg h ijk";
var ans = s.split(" ");
// ans[0]:abcd ans[1]:efg ans[2]:h ans[3];ijk

文字列内の、指定位置からの指定された長さを持つ部分を返します。

str = "abcdefghij"
print(str.substr(1,2))  // bc
print(str.substr(-2,2)) // ij
print(str.substr(1))    // bcdefghij
print(str.substr(1,20)) // bcdefghij
print(str.substr(20,2)) // ""

0 と 文字列の長さから 1 引いた数の間にある整数。

0 と文字列の長さの間にある整数。省略した場合、文字列の長さ。

ia から ib 未満の文字を取り出します。

var anyString="abcdefgh" 

// "abc"
print(anyString.substring(0,3));
print(anyString.substring(3,0));

// "efg"
print(anyString.substring(4,7));
print(anyString.substring(7,4));

// "abcdefg"
print(anyString.substring(0,7));

// "abcdefgh"
print(anyString.substring(0,8));
print(anyString.substring(0,10));

// "efgh"
print(anyString.substring(4));

すべての英字を小文字に変換した文字列を返します。

var upperText="ALPHABET"
alert(upperText.toLowerCase()) // alphabet

文字列オブジェクトを生成するソース文字列を返します。

str = "abcdefghij"
alert( str.toSource() ); // (new String("abcdefghij"))

文字列オブジェクト内の文字列を返します。

str = "abcdefghij"
alert( str.toString() ); // abcdefghij

すべての英字を大文字に変換した文字列を返します。

var lowerText="alphabet"
alert(upperText.toUpperCase()) // ALPHABET

前後の空白文字を削除した文字列を返します。

前の空白文字を削除した文字列を返します。

後の空白文字を削除した文字列を返します。

文字列オブジェクト内の文字列を返します。

str = "abcdefghij"
alert( str.valueOf() ); // abcdefghij

var wm1 = new WeakMap(),  
    wm2 = new WeakMap();  
var o1 = {},  
    o2 = function(){},  
    o3 = window;  
  
wm1.set(o1, 37);  
wm1.set(o2, "azerty");  
wm2.set(o1, o2); // a value can be anything, including an object or a function  
wm2.set(o3, undefined);  
wm2.set(wm1, wm2); // keys and values can be any objects. Even WeakMaps!  
  
wm1.get(o2); // "azerty"  
wm2.get(o2); // undefined, because there is no value for o2 on wm2  
wm2.get(o3); // undefined, because that is the set value  
  
wm1.has(o2); // true  
wm2.has(o2); // false  
wm2.has(o3); // true (even if the value itself is 'undefined')  
  
wm1.has(o1);   // true  
wm1.delete(o1);  
wm1.has(o1);   // false