2014年01月07日

配列のコピーの件 いまさら

今更ながらなんで配列のコピーが
Array.apply(null, arr)

じゃダメなんだっけ?で悩んでしまったので。
var arr[1, 2];
var arr_copy = Array.apply(null, arr); //[1, 2]

ならいいんだけど、要素が1つの配列だとコピーされない。
var arr[3];
var arr_copy = Array.apply(null, arr); //[]

これは配列のコンストラクタを呼び出している(newなくてもよいの?)
var arr_copy = Array(3);

Arrayのコンストラクタは
[element0, element1, ..., elementN] //配列リテラル
new Array(element0, element1, ..., elementN)
new Array(arrayLength)

なので、要素数3の配列を作成しているのでした!
最後のパターンを忘れていたのでした。
posted by ほえ at 11:27| Comment(0) | TrackBack(0) | JavaScript | このブログの読者になる | 更新情報をチェックする

2010年08月31日

同じDOMをjQueryで選択したら違うオブジェクトなになるのだ。


var a = $('#abc');
var b = $('#abc');
if (a != b) {
console.log('chigau!');
}

だと'chigau!'になるのです。

こうすればよいようです。

if (a.get(0) != b.get(0)) {
console.log('chigau!');
}

.get()は、jQueryが選択しているDOMオブジェクトを返してくれます。
複数選択している場合もあるから、1つだけの時でも.get(0)で。
.get()のままだとコンソールに

[div#abc]

みたいに表示されて、なんだこれは?と悩む事になります。配列ですね。
posted by ほえ at 18:07| Comment(0) | TrackBack(0) | JavaScript | このブログの読者になる | 更新情報をチェックする

私はだあれ?の巻

iframeの中から、自分は親のどのiframeなのか知りたくて。
frameはいろいろ難しくて、window.parent.fames...とかいろいろやってみたけれど。
こんな簡単だったのね。

var me = window.frameElement;

ウィンドウがトップレベルだったらnullになるそうです。

これもDOM Level 0。
posted by ほえ at 17:57| Comment(0) | TrackBack(0) | JavaScript | このブログの読者になる | 更新情報をチェックする

2010年06月01日

配列のコピーの件


var arr = [1, 2];
var arr_copy = Array.apply(null, arr);
alert(arr_copy); //[1,2];

だけども、

var arr = [1];
var arr_copy = Array.apply(null, arr);
alert(arr_copy); //;

だと、[1]にならない。

こうするそうです。

var arr = [1];
var arr_copy = Array.prototype.slice.apply(arr);
alert(arr_copy); //[1];


引数なしのslice()っていったい…。
posted by ほえ at 15:12| Comment(0) | TrackBack(1) | JavaScript | このブログの読者になる | 更新情報をチェックする

2009年04月07日

Bloglinesの広告がヤな件

Bloglinesに表示される広告がヤなので、Greasemonkeyのスクリプトを書いて表示しないようにした。一瞬出ちゃうけど。

window.addEventListener(
'load',
function () {
var f = window.frames[1].document;
var iya = f.evaluate('//body/table[2]/tbody/tr/td/table/tbody/tr/td[2]', f.body, null, 7, null);

iya.snapshotItem(0).style.visibility = 'hidden';
},
false
);


ずっとアドオンは入ってたけど使っていなかった。必要は発明の母ですね。発明じゃないか。
ついでにXPathもちょっと使った。便利だなぁ。
posted by ほえ at 13:51| Comment(0) | TrackBack(0) | JavaScript | このブログの読者になる | 更新情報をチェックする

2008年08月01日

cons, car, cdr


var cons = function (x, y) {
function dispatch(m) {
if (m == 0) {return x}
else if (m == 1) {return y}
else {alert('error!')}
};
return dispatch;
};
var car = function (z) {return z(0)};
var cdr = function (z) {return z(1)};

var x = cons(1,2);
car(x); // -> 1
cdr(x); // -> 2

posted by ほえ at 17:51| Comment(0) | TrackBack(0) | JavaScript | このブログの読者になる | 更新情報をチェックする

2008年05月30日

メソッドのオーバーライドの件

JavaScriptで、メソッドのオーバーライドを行うには、次のようにするといいそうです。
var Parent = function (name, age) {
this.name = name;
this.age = age;
}
var Child = function (name, age, gender) {
Parent.apply(this, arguments);
this.gender = gender;
}
Child.prototype = new Parent();
もしくは
var Child = function (name, age, gender) {
Parent.call(this, name, age);
this.gender = gender;
}
Child.prototype = new Parent();
で。
applyとcallは「別のオブジェクトのメソッドを異なるオブジェクト(呼び出すオブジェクト)のコンテキスト内において適用します。」ですって。

apply か call を使わないと次のようになるようです。
var Child = function (name, age, gender) {
this.base = Parent;
this.base(name, age);
this.gender = gender;
}
Child.prototype = new Parent();




ここでまたthisです。
var Child = function (name, age, gender) {
Parent(name, age);
}
Child.prototype = new Parent();
としてしまうと、Parentを呼び出した文脈(コンテキスト)でthisが解釈されてしまいます。このまま
var c1 = new Child('hoe', 10, 'male');
とChildを呼び出すと、文脈はグローバルオブジェクト、つまりwindowになってしまいます。
結果、
alert(window.name + '::' + window.age); //-> 'hoe::10'
です。

thisって奴ぁ…。
posted by ほえ at 16:44| Comment(0) | TrackBack(0) | JavaScript | このブログの読者になる | 更新情報をチェックする

2008年05月19日

getComputedStyle()をIEで!の件

ffではgetComputedStyle()で、CSSがレンダリングされた結果の値?を取れるので、IEでも!と思ったら、IEにはありませんでした。
でも、各要素にcurrentStyleというプロパティがあるそうなので、使ってみました。


<html>
<head>
<script type="text/javascript">

function hoho(elm)
{
var css = elm.currentStyle || window.getComputedStyle(elm, null);
alert(css.height);
}

</script>
</head>
<body>

<div onclick="hoho(this);">あいうえお</div>

</body>
</html>


ffでは、
19.2px
とか出てきて、ヤッター!ですが、
IEでは、
auto
ですって。がっかり。
posted by ほえ at 12:38| Comment(0) | TrackBack(0) | JavaScript | このブログの読者になる | 更新情報をチェックする

2008年04月22日

まだわかってない!

○オブジェクト
var a = {};


○関数オブジェクト
var f = function(){};


○コンストラクタ
関数は全てコンストラクタ。

○new
objectName = new objectType(param1 [,param2] ...[,paramN])


○objectType
関数

○コンストラクタ、objectType、関数
コンストラクタ = objectType = 関数


var a = {};             //<- object
var f = function() {}; //<- function object

var ff = new f(); //<- object


※グローバル関数は?
var a = new eval(); //function eval must be called directly, and not by way of a function of another name(ff)
このオブジェクトではサポートされていない操作です。(IE)


…特殊なようです。


--------------------
○shared property
prototype

var f = function() {};
f.prototype.func = function(){console.log('f!')};
var ff = new f();
ff.func(); //'f!' <- f.prototype.func
f.prototype.func = function(){console.log('F!')};
ff.func(); //'F!' <- f.prototype.func

var g = function() {
this.func = function(){console.log('g!')}
}
g.setfunc = function(){this.func = function(){console.log('G!')}}
var gg = new g();
gg.func(); //'g!' <- オブジェクトggのプロパティ func
g.setfunc();
gg.func(); //'G!' <- オブジェクトggのプロパティ func


------------
○継承
var a = {};             //<- object
var f = function() {}; //<- function object
var ff = new f(); //<- object

なので、
var fff = new ff();

はエラーです。
これだと、

親クラス        :f
子サブクラス :ff
孫サブサブクラス:fff


にできないから、継承できないのでは?
そこでprototype。
var f = function() {};      //<- fのコンストラクタ
var ff = function() {}; //<- ffのコンストラクタ
ff.prototype = new f(); //<- ffの親はf
var fff = function() {}; //<- fffのコンストラクタ
fff.prototype = new ff(); //<- fffの親はff

var fff_instance = new fff();


で、どうかしら?
posted by ほえ at 17:13| Comment(0) | TrackBack(0) | JavaScript | このブログの読者になる | 更新情報をチェックする

2008年04月02日

イベントのキャンセルの件

こんな時、

<pre onclick="alert('hoe');" style="background-color:blue;">
hoe
<pre onclick="alert('hoehoe');" style="background-color:yellow;">hoehoe</pre>
</pre>

hoehoeをクリックすると、

hoehoe
hoe

と、両方のイベントハンドラが動いてしまうので、
hoehoeのイベントハンドラを実行した後に、イベントの伝播をキャンセルしたいです。
event.stopPropagation()

を使えばいい事がわかったのですが、このeventはどこに?

eventオブジェクトはデフォルトでイベントハンドラにパラメータで渡されるそうです。

function hoe(evt) {
alert(evt);
}
<a onclick="hoe();">hoe</a>

で、hoeを呼び出す時に呼び出し側でeventオブジェクトを明示的に引数として渡す必要がないという事です。

じゃあ、こんな時は?

function func(str) {
alert(str);
}
<a onclick="func('hoe');">hoe</a>

関数funcにパラメータを渡したいのですが、デフォルトで渡されるeventオブジェクトはどこに?
こうするそうです。

function func(evt, str) {
alert(str);
}
<a onclick="func(event, 'hoe');">hoe</a>

呼び出し側で指定している引数eventは「eventという名前の定義済みの引数」だそうです。

func('hoe', event)

って順番間違えれば当然eventオブジェクトがalert()で表示されます。

IEではevent.stopPropagation()がないので、
evt.cancelBubble = true;

を使えばよいそうです。

結果、こんな感じに。

function func(evt, str) {
alert(str);

if (evt.stopPropagation) {
evt.stopPropagation();
} else {
evt.cancelBubble = true;
}
}

<pre onclick="func(event, 'hoe');" style="background-color:blue;">
hoe
<pre onclick="func(event, 'hoehoe');" style="background-color:yellow;">hoehoe</pre>
</pre>


はいー(世界のナベアツ風に)。
posted by ほえ at 12:09| Comment(0) | TrackBack(0) | JavaScript | このブログの読者になる | 更新情報をチェックする

2008年03月27日

arguments.calleeの件

マニュアルに書いてあることだけれど、arguments.calleeの件

var hoe = function () {
return function (num) {
if (num > 0) {
return num + arguments.callee(num - 1);
} else {
return 0;
}
}
}
alert(hoe()(10)); // <- 55

無名関数は名前が無いので、再帰の時などに自分自身を名前を使って呼び出すことができません。
なので、calleeができましたとさ。
posted by ほえ at 17:58| Comment(0) | TrackBack(0) | JavaScript | このブログの読者になる | 更新情報をチェックする

上のスコープの変数の値の件

JavaScriptでこんな時

var hoe = function () {
var vv = 10; // <- これをalert()で表示したい!
var hoehoe = function () {
var vv = 100;
alert('親のvvは' + ??);
}
}

??にはなんて書けばいいんでしょ?
posted by ほえ at 17:41| Comment(0) | TrackBack(0) | JavaScript | このブログの読者になる | 更新情報をチェックする

2008年03月15日

JavaScriptのprototypeについていまさらな件

いまさらだけど、なんとなく漠然としていたのがはっきりした気がしたのでメモしておきます。

prototypeは共有されるのです。


function hoe() {
this.hello = function () {
alert('hoehoe!');
}
}
hoe1 = new hoe();
hoe2 = new hoe();
hoe3 = new hoe();

とすると、hoe1, hoe2, hoe3それぞれ別々にhelloメソッドを持つわけです。


function hoe() {};
hoe.prototype.hello = function () {
alert('hoehoe!');
}
hoe1 = new hoe();
hoe2 = new hoe();
hoe3 = new hoe();

とすると、共通でhelloメソッドを持ちます。

メモリを無駄に使わなくて済むのですね!
posted by ほえ at 13:45| Comment(0) | TrackBack(0) | JavaScript | このブログの読者になる | 更新情報をチェックする

2007年11月15日

location.hash

window.location.hashは
http://xxx.xx.xx/xxx.php#abc
のabcの部分の事です。
http://xxx.xx.xx/xxx.php?abc
だとサーバにデータを取りに行くけど、location.hashはローカルのページ内での遷移だけです。
しかもブラウザの戻るボタンで前の状態に戻れる。

なるー。すごいな。


posted by ほえ at 12:17| Comment(0) | TrackBack(0) | JavaScript | このブログの読者になる | 更新情報をチェックする

2007年10月23日

IE6のタグのhrefにJavaScriptを書いてはまる件

function hoehoe(c) {
if (c) {
return false;
}
document.frm.submit();
}
:
<a href="javascript:hoehoe(true);">Aタグ</a>
<form name="frm">
:
</form>

とこんな風に書いて、Aタグをクリックしたら、ページに
false
と出てきてちびりそうになりました。
そこで
<a href="javascript:void(0);" onClick="hoehoe(false);">Aタグ</a>

としたら、falseを引数にしたので、submit()までコードが実行されるのですが、IE6で次のページに行かなくなってしまいました。
firefoxでは次のページに行きます。

<a href="javascript:void(0);" onClick="hoehoe(false); return false;">Aタグ</a>

とonClickの最後にreturn false;を書かないとダメなようです。

忘れるのでメモしておきます。
posted by ほえ at 19:28| Comment(0) | TrackBack(0) | JavaScript | このブログの読者になる | 更新情報をチェックする

2007年08月20日

thisの件

window.setInterval()や、addEventListner()、attachEvent()で関数を指定する時のthisの件についてなんとなくわかっていたような気がしていましたが、わかっていなかったので調べてみました。

まず、thisはキーワードです。読み取り専用です。
thisはカレントオブジェクトを参照できます。
function hoe() {
this.name = 'hoe desu!';
this.age = '10 sai!';
}
var hoehoe = new hoe();
alert(hoehoe.name); //'hoe desu!'
alert(hoehoe.age); //'10 sai!'

としてコンストラクタ関数でオブジェクトのプロパティの初期化などに使用します。
この場合、関数hoe内のthisは新しく作成されて変数hoehoeに結びついているオブジェクトを参照しています。カレントオブジェクトはhoehoeです。
もし、newしないで、関数hoeをそのまま呼び出すと、
hoe();
alert(name); //'hoe desu!'
alert(age); //'10 sai!'

グローバル変数 name と age が作成されました。
これは this がブラウザ上でのグローバルオブジェクトである window を参照しているからです。window.name、window.ageに値を設定しているという事です。

...
function hoe2(obj) {
alert(obj.id);
}
...
<input type="button" id="button1" onclick="hoe2(this)">
...
と、フォーム要素のonclickで、thisを引数にして関数を呼ぶと、thisは呼び出しもとのフォーム要素を参照するようになります。
ここで
function hoe3() {
alert(this);
}
...
<input type="button" id="button2" onclick="hoe3()">
...
とすると、thisはwindowを参照します。
hoe3は、ただ関数を呼び出しただけです。フォーム要素もオブジェクトですが、そのオブジェクトのメソッド内で関数を呼び出しただけです。なので、thisはwindowを参照する事になります。
hoe2(this)の場合は、hoe2を呼び出した時点でフォーム要素オブジェクトを参照するthisを引数にしているという事になります。

thisの話になると、必ず出てくるsetInterval()を使ってみます。
なんとなくこんな感じというコードを書いてみます。
function hoe() {
this.count = 0;
this.countUp = function() {
this.count++;
if (this.count > 3) {
clearInterval(this.interval_id);
}
};
this.start = function() {
this.interval_id = setInterval(this.countUp, 500);
};
}
var obj_hoe = new hoe();
...
<input id="button3" type="button" onclick="obj_hoe.start()">

...

これは予想した動作を行わずに、延々と
NaN
を表示し続けます。hoeの中で定義されている関数countUp()を呼び出しているのですが、setIntervalに設定された関数countUp内で、thisがwindowになってしまっているからです。
setIntervalに設定する時にはthisはhoeを参照しています。
一定時間毎に呼び出される時countUp関数内のthisはwindowを参照しています。
countUpはhoeのメソッドではないですか!と思いますが、setIntervalにしてみれば、「なんだか知らないが関数が指定された」だけです。
オブジェクトhoeと、setIntervalに指定された関数とは関係がないと言う事です。hoeはcountUp関数をプロパティとしてはいるけれども、countUp関数はhoeに所属しているわけではないという事です。
function hoe() {...の前に
var count = 0;
とグローバルの変数countを追加すると、NaNではなく数字をカウントアップするようになります。但し、関数countUp内のthis.interval_idがwindow.intervl_idを参照しているため、数字が3より大きくなっても停止しません。

setIntervalで呼ぶ関数を、無名関数でラップ(包む)してみます。

// this.interval_id = setInterval(this.countUp, 500);
this.interval_id = setInterval(function() {this.countUp()}, 500);

(関数の中で別の関数を呼ぶので、this.countUpではなくて、this.countUp()です。function xxx() {alert}ではなくて、function xxx() {alert()}と同じです。)
これを実行すると、エラーになります。今度はhoeの中で定義されている関数countUp()を呼び出していません。setInvervalで設定している関数のthisがwindowになってしまっているからです。
setIntervalが一定時間毎に無名関数
function() {...}
を呼び出しています。その関数のbodyで使用されているthisは実行時に参照を解決するので、参照先はwindowとなるのです。
試しにvar obj_hoe = new hoe();の後に
function countUp() {alert('global no countUp desu!');
とグローバルの関数を定義すると、'global no countUp desu!'と表示し続けます。

今度はsetIntervalに関数を設定する前に、ローカル変数selfを作成し、thisを入れておきます。(selfは特別意味のあるものではなく、慣例的にselfという名前の変数を使用するという事のようです。)
this.start = function() {
// this.interval_id = setInterval(this.countUp, 500);
// this.interval_id = setInterval(function() {this.countUp()}, 500);
var self = this;
self.interval_id = setInterval(function() {self.countUp()}, 500);
};

今度は当初の目論見どおり、1から4まで数字を表示して停止しました。

これまで、なぜこうなるのかわかりませんでした。
setInterval(function() {....}, 500);

とした時点で、この無名関数はクロージャを作成しているのですね?
クロージャはその環境を保存しますから、
var local_value = xxx;
setInterval(function() {....}, 500);

とまわりにローカル変数があれば、クロージャにその値が保存され、クロージャが呼び出される度にその値が使われるという事です。
thisは変数ではなくて、キーワードだから呼び出される度に、その時の呼び出し元のオブジェクトを参照する。
selfはクロージャが作成された時点で、thisが参照しているオブジェクト、つまりhoeを保存しているので、呼び出される度にhoeを参照できるという事です。

やっとわかりました。
posted by ほえ at 15:45| Comment(1) | TrackBack(0) | JavaScript | このブログの読者になる | 更新情報をチェックする

2007年08月06日

new演算子の件

JavaScriptのオブジェクトを作成する件で混乱していました。
オブジェクトを作成するのに、
var Hoe = {name:'hoe desu', type:'object literal desu!'}
としても、
var Hoehoe = function() {
this.name = 'hoehoe desu!';
this.type = 'function desu!';
}
としても良いとあるのに、「何かが違う」のです。
何が違うのかわからないのですが、作成したオブジェクトに対して何かしようとすると片方はできるのにもう片方はできなかったり…。

そのひとつが new する事でした。
var hoe = new Hoe(); //エラー。Hoe is not a constructor
で、
var hoehoe = new Hoehoe();
はもちろんエラーにはならないのです。
「new演算子はコンストラクタ関数のあるオブジェクトのインスタンスを作成する」ものだからです。
じゃあ、コンストラクタ関数って何?となりますが、これは、ちょっと置いておいて。


もうひとつがprototypeプロパティです。
alert(Hoe.prototype); //undefined
hoe.prototype.hoe_proto = 'hoe_proto degansu!'; //エラー。hoe.prototype ha no property
で、
alert(Hoehoe.prototype); //[object Object]
Hoehoe.prototype = 'hoehoe_proto degansu!';
はもちろんエラーにはならないのです。
さらにはもちろん
var hoehoe = new Hoehoe();
alert(hoehoe.hoehoe_proto); //'hoehoe_proto degansu!'
なのです。


さて、newの件に戻ります。
objectName = new objectType(param1 [,param2] ...[,paramN])
となっています。
objectType??と思うわけです。で、
 objectType 
Object type. It must be a function that defines an object type.
となっているわけです。
object typeを作成するには、
1. 関数を記述してobject typeを定義する
2. newでインスタンスを作る
とあります。
object typeを定義するには、object typeの為に名前、プロパティ、メソッドを指定する関数を作成します。
という事です。どうやらオブジェクトとobject typeというのは別物らしいと、ここら辺で気がつきました。
じゃあ、object typeとコンストラクタの関係は?
「1. 関数を記述してobject typeを定義する」の関数がコンストラクタ関数です。要するにobject typeというのは、コンストラクタそのものという事ですね。
関数 = object type = コンストラクタ

です。関数がthisを使ってプロパティを設定していなくても、それはコンストラクタなのです。なんだか元に戻った感じがします。

次。prototypeの件。
まず、prototypeは全てのオブジェクトの親である、グローバルオブジェクトObjectのプロパティではありますが、これはFunctionオブジェクトのプロパティprototypeなのです。つまりobject typeのプロパティ、コンストラクタのプロパティです。
prototypeの役目は、shared propety、共有プロパティなので、共有できないただのオブジェクトにあってもしょうがない?newして共有できる関数オブジェクトにだけあるという見方はできるのでしょうか。


var hoe1 = {
name:'hoe desu!',
age:40
}
で作成されたオブジェクトhoe1は、
var Hoe = function(){
this.name = 'hoe desu!';
this.age = 40;
}
var hoe2 = new Hoe();
で作成されたオブジェクトhoe2にあたるものと思えば良い訳ですね?
このエントリで書いた混乱の元は、なんとなくプロトタイプベースの言語というののイメージが頭で出来上がっていて、それは「オブジェクトからオブジェクトを作成する」というもので、「何かオブジェクトがあれば、それを直接newしてオブジェクトを作成できるんだ」と思い込んでいた事が原因のようです。
クラスベースの言語と同じように、オブジェクトの型(object type)というものがあって、そこから新しくオブジェクトを作るのですね。
何でもnewすりゃいいじゃん!htmlでテーブルが定義されていたら、それをnewしてもう一個テーブルが作れるじゃん!とかテーブルの列をnewして同じ列が作れるじゃん!勘違いしている事もありました。

hoe = function(p) {
this.val = p;
}
hoe.prototype.setVal = function(p) {
this.val = p;
}
hoe.prototype.getVal = function() {
return this.val;
}
としている時に、このhoeのprototypeプロパティはなんだろうと思ったらよくわからなくなってしまいました。
関数?でも
prototype = function() {...}
じゃないしなぁ。とか
オブジェクト?でもsetValとgetValと2つも定義してるんだけど…。とか。
で、"名前"と"値"の組は全てオブジェクトなのです。
hoe.prototype = {
getVal = function() {...},
setVal = function() {...}
}
と書き換えると、オブジェクトなんだっていう見方がしやすいかと思います。
obj = {}
が一番簡単なオブジェクトですもんね。
posted by ほえ at 16:03| Comment(0) | TrackBack(0) | JavaScript | このブログの読者になる | 更新情報をチェックする

2007年08月02日

配列を作る件 その2

配列リテラルを使っても配列を作成できます。
arr = ['hoe1', 'hoe2'];
これで要素が'hoe1', 'hoe2'の長さが2の配列が出来ます。
arr = ['hoe1', , 'hoe3'];
で、要素が'hoe1', 空の要素, 'hoe3'の長さが3の配列が出来ます。

arr1 = new Array('hoe1', 'hoe2', 'hoe3);
の時、
arr1[0] は 'hoe1'
arr1[1] は 'hoe2'
arr1[2] は 'hoe3'
です。

同様に
arr2 = ['hoe1', 'hoe2', 'hoe3'];
の時も、
arr2[0] は 'hoe1'
arr2[1] は 'hoe2'
arr2[2] は 'hoe3'
です。

arr3 = new Array();
で、長さ0の配列を作成します。
alert(arr3.length); //0
このarr3に、
arr3[0] = 'hoe1';
arr3[1] = 'hoe2';
arr3[2] = 'hoe3';
と、現在の長さより大きい要素に値を代入すると、配列の長さが伸びます。
alert(arr3.length); //3

arr3[100] = 'hoe101';
とすると、配列arr3の長さは101になります。
alert(arr3.length); //101

これはArrayオブジェクトが長さlengthを自動的に設定しているからです。
posted by ほえ at 15:31| Comment(0) | TrackBack(0) | JavaScript | このブログの読者になる | 更新情報をチェックする

2007年07月14日

配列を作る件 その1

JavaScriptで配列を作成するには、
new Array(3); //長さ3の配列
new Array(1, 2, 3); //要素1,2,3の配列
[1, 2, 3]; //要素1,2,3の配列

と3つの方法があります。ってここでもう変な感じに…。
じゃあ、長さ1で、要素が3の配列を作るのに、
new Array(3);

は使えないって事ですね。
でも、
new Array('3');

では、長さ1で、要素が'3'という文字列の配列ができるのですね。
で、
new Array(0);

は?長さが0の配列です。
では、
new Array(-1);

は?要素が-1の配列かと思ったら、エラーになりました。
var arr = new Array(1);
arr[0] = 3;

とするか、
var arr = new Array();
arr[0] = 3;

とするか、
var arr = [3];

とすればよいのですね。

なんだかいきなり躓いた感が…。
posted by ほえ at 18:37| Comment(0) | TrackBack(0) | JavaScript | このブログの読者になる | 更新情報をチェックする

2007年07月05日

関数を作る件で?

(function() {
...
})()

無名関数の最後に()をつける事で、その場でその無名関数を実行しているという事でよいのですが、それが
new function() {
...
}
とも書けるという事が解りませんでした。
が、
function () {
...
}

は無名関数のコンストラクタという事で、
new ...

で、そのコンストラクタを実行している。
という事だと考えればよいのですな。きっと。

括弧が減りました。
…まだそれほどわかってない。
事が多い。
posted by ほえ at 23:50| Comment(0) | TrackBack(0) | JavaScript | このブログの読者になる | 更新情報をチェックする

広告


この広告は60日以上更新がないブログに表示がされております。

以下のいずれかの方法で非表示にすることが可能です。

・記事の投稿、編集をおこなう
・マイブログの【設定】 > 【広告設定】 より、「60日間更新が無い場合」 の 「広告を表示しない」にチェックを入れて保存する。


×

この広告は1年以上新しい記事の投稿がないブログに表示されております。