スポンサーサイト
上記の広告は1ヶ月以上更新のないブログに表示されています。
新しい記事を書く事で広告が消せます。
Javaにmainメソッドはいらないんですね
public class A {

	static {
		int i = 1;
		i++;
		System.out.println(i);
	}
	
}

結果:
2
Exception in thread "main" java.lang.NoSuchMethodError: main
スポンサーサイト
ベベルとエンボス
ベベル
http://f11.aaa.livedoor.jp/~hige/index.php?%5B%5B%A5%D9%A5%D9%A5%EB%5D%5D
「面取り」のこと。角を滑らかにすること。

エンボス
http://ja.wikipedia.org/wiki/エンボス
浮き彫りにする加工のこと。

[その他参考資料]
http://coupy.ojaru.jp/illustrate/course/n01/PSnurikata2.html
Hackerと呼ばれた
おい、皆。

生まれて初めて Hacker と呼ばれたぞw
Perlでアダプターパターンを考えてみる
アダプターパターンは、関数の呼び出し方が俺好みじゃないのだが......
といったときに使われる。 Perlでみてみよう。

sub say {
  my $c = shift;
  print "$c" . "\n";
}

これは、
say('hoge');
といった感じで呼び出せる。

このソースがあったとき、
なにぃーー!!、名前付き引数で渡せないだとぉおおおおおおお!と憤慨したとしよう。
しかし、say はもう無事に動いてるのだし、これを利用しない手はない、そこで、

sub say_with_name {
  my $c = shift;
  say ($c->{'name'});     # ここで委譲
}
こういうソースが書ける。
こうすれば、
say_with_name ({name=>'hoge'}):
で呼び出せる。

しかし、名前付きで呼び出すのなんて、ハッシュへのリファレンスを理解してないと使えないではないか!!!いったい君はなにを考えているんだ。という人がいたとして、次のように書き換える。

sub say_no_name {
  my $c = shift;
  say_with_name({ name => $c });   # ここで委譲
}

こうすれば、
say_no_name('hoge');

と普通に呼び出せる。

こうして、ソースの難読化は進んでいくんだ。
このルビーを
h = Hash::new

["a","b","c","d"].each { |x| h[x] = File.open(x,"w") }
["a","b","c","d"].each { |x| h[x].puts "oooo"        }
["a","b","c","d"].each { |x| h[x].close              }

これと同じことをPerlでやりたいのだが、

use strict;

my %c;
for( qw| a b c d | ){
  open $c{$_}, ">$_";
}

for( qw| a b c d | ){
  print $c{$_} "oooo";
}

for( qw| a b c d | ){
  close $c{$_};
}

これだと、文法エラーなんだよなぁ........


そもそも、Perlのファイルハンドラの扱いは
ややこしそうで、文法がうまくいったところで、このやりかただと
うまくいかないっぽいなぁ.....


ファイル系のモジュール使うと実現するのだろうか....

グロブとかも理解しないと越えられないのだろうか.....
ん~~~~~
さっそく うまくいかない.....

なんでもよいので div要素をクリック。
そうかーーーーーーー!!!!
イベントがバブリングしてるとか あれですかぁ


ソースこれだしーーー
$("div").click( function(){ $(this).animate({ height:20 },"slow") } );

大変うっとうしので、スクリプトは削除したため、
div要素をクリックしてもなにも起こりません。
はじめてのJQuery
click me
CSSルール
あってんのかよくわからないが、
CSSの内容(CSSルール?)を全部表示させる方法。
改行を入れるのに br タグを作って入れて~
ってのがめんどくさいので実装してないので見にくい.............


cssRulesはitemメソッド持ってると書いてたが、
動かなかったのは何故だろう?
タイプミス? よくわからん


ん~。
http://www.kawa.net/works/js/jkl/dumper.html で、見てみると、itemメソッドは確かにあるなぁ。
ということはタイポだったのかな。

しっかし、上記のDumperではネーティブコードとなって、
cssRulesとかの詳しい中身が見れないんですな><

まあ、なんとなくJSのCSSルール(?)の仕組みはわかった。
あくまで、なんとなくだが。


で、さらに勉強。

なるほど、CSSルールが、おのおのCSS宣言を持ってる形か。
これは、うっとうしい。なにかしらのライブラリを使わなくては。
var str="";
for(var j=0;
    j < document.styleSheets.length;
    j++
   )
{
   for(
       var i=0;
       i < document.styleSheets.item(j).cssRules.length;
       i++
      )
   {
    str = str
        + 'セレクタテキスト: '
        + document.styleSheets.item(j).cssRules[i].selectorText
        + 'CSSテキスト   : '
        + document.styleSheets.item(j).cssRules[i].style.cssText;
   }
}
document
.getElementById('foobar')
.firstChild.nodeValue = str;

別のCSSを読み込ませる方法
別のCSSを読み込ませる方法。
こんな感じかしら。

本当は、改行なしで書いた。
<input type="button"
 value="push" 
 onclick="document.getElementsByTagName('link').
 item(0).
 href='http://bingobingobingo.blog49.fc2.com/template/fc2_plus24_JS/style.css'" />


色ワルゥ。
ちょっとPerlで遊んでみよう。 part5
use strict;

print ((sub {
         my ($f, $fn, $c, $d ) = @_;

         $fn->($f, $c, $d);
      })->(
           sub { $_[0]+$_[1] },
           sub { $_[0]->($_[1], $_[2])*2 },
           7,
           2
          ));
イベントリスナーの力を使うんだ
イベントリスナーを使えば、複数登録できるんだねぇ。
すごいねぇ。

以下のソースはFirefoxのみ。
<div id="id">click me</div>
<script>
document.getElementById('id')
        .addEventListener('click',
                           function(evt){
                                     alert('押された' + ' タイプは' + evt.type)},
                           false
                         );

document.getElementById('id')
        .addEventListener('click',
                           function(evt){
                                     alert('I was Pushed' + ' type is ' + evt.type)},
                           false
                         );
</script>

旧来のイベントハンドラの指定と違い、
関数は実行させるようにはかかないんだねぇ。

旧来      : onclick="hoge()"
イベントリスナー: 'click', 'hoge', false



click me
Nodeに足し込む part2
<script>
function f(){
             document.getElementsByName('hoge') 
                     .item(0) 
                     .appendChild(
                                   document.createElement('div')
                                           .appendChild(
                                         document.createTextNode('できたよ')
                                 )
             )
            };
</script>
<input type="button" onClick="f()" />


なるほど、ということは、
<input type="button" value="push"
       onClick="(function(){
           document.getElementsByName('foo')
                   .item(0)
                   .appendChild(
                               document.createElement('div')
                                       .appendChild(
                                   document.createTextNode('fooができたよ!!')
                               )
                   )
          })();" />
と、書いてもよいわけか。
最近は、めっきりvi党
最近のJava以外のソースは、
viで書いてます。 といってもvim(?)ってやつかな。
Nodeに足し込む
document.getElementsByTagName('body')
.item(0)
.appendChild(
document.createElement('div')
.appendChild(
document.createTextNode('できたよ')
)
)

.(ドット)をどうインデントして書こうかと思ったが........
誤解を招きそうだが、インデントが深くなると嫌なので上記のようにした。



なるほどJavaScript
要素ノードとテキストノードは違うんだ。
ということですな。

<div id="id">aaaa</div>
<script>
alert(
document
.getElementById('id')
.firstChild.nodeValue
);

document
.getElementById('id')
.firstChild.nodeValue = 'bbbb';
</script>

aaaa


参考資料:
http://www.tagindex.com/cgi-lib/q4bbs/patio.cgi?mode=view&no=1696
http://seasaw.eek.jp/wordpress/?p=14
Perlでコンポジットパターン
再帰のうっとうしいパターン
(本当は再帰してるわけではないのだが、イメージ的に近い感じ)


関数呼び出しを再帰させるわけではないので 、
配列かなにかでスタックは直書き(自分で実装)。
で、先にスタックに全部ぶちこんでから実行という感じ。


Javaだと、やけに型にこだわるので、いや、自分自身が持てることが重要だろう!
とかなりそうだが、Perlにはそんな制約ないので、これでよいと思う。
なんというか、ここで言いたいのは実装のイメージ(こんな風に書くという)。

次のソースは、とりあえず書いてみたという感じなので、読みにくいと思われる。

Hoge.pm
package Hoge;
use strict;

sub new {
my $self = shift;
my $c = shift;

bless $c;
}

sub add {
my $self = shift;
my $c = shift;

push @{$self->{Foos}}, $c;
return $self;
}

sub say {
my $self = shift;

print "$self->{'name'}" . "だよ" . "\n";
for( @{$self->{Foos}} ){
$_->say();
}
}

1;


Foo.pm
package Foo;
use strict;

sub new {
my $self = shift;
my $c = shift;
bless $c;
}


sub say {
my $self = shift;

print ">>> " . "$self->{name}" . "だよ" . "\n";
}

1;



main.pl
use Hoge;
use Foo;
use strict;

my $top = Hoge->new({name=>'top', Foos=>[]})
->add(
Hoge->new({name=>'Hoge1'})
->add(Foo->new({name=>'Foo1'}))
->add(Foo->new({name=>'Foo2'}))
)
->add(
Hoge->new({name=>'Hoge2'})
->add(Foo->new({name=>'Foo3'}))
->add(Foo->new({name=>'Foo4'}))
);

$top->say();


結果:
topだよ
Hoge1だよ
>>> Foo1だよ
>>> Foo2だよ
Hoge2だよ
>>> Foo3だよ
>>> Foo4だよ


Perlでのオブジェクト指向 インスタンス変数はどうするのか
さて、ではPerlでのオブジェクトが持つ変数はどう書けばよいのだろうか。
次のソースを考えてみよう。

Hoge.pm
package Hoge;
use strict;

my $d = 2;

sub new {
bless {};
}


foo.pl
use Hoge;
use strict;

my $c = Hoge->new();
print $c->$d;

このように書いてアクセスできればよいのだが、これではエラーになってしまう。

困った。

しかし、関数へのアクセスはできる。
では、ゲッター、セッターを書けばどうなるのだろうか。

Hoge.pm
package Hoge;
use strict;

my $d = 2;

sub new {
bless {};
}

sub get_d{ return $d };
sub set_d{ $d = $_[1] };

1;


foo.pl
use Hoge;
use strict;

my $c = Hoge->new();
print $c->get_d() . "\n";
$c->set_d(1);
print $c->get_d() . "\n";

結果:
2
1

となって、みごとオブジェクトの変数にアクセスできた。
しかし、私はこの方式がとられているのを見たことがない。

では、一般的に使われている方法はどうするのだろうか。
結論から先に書くと、ハッシュを使う。

ソースを見てみよう。
Hoge.pm
package Hoge;
use strict;

sub new {
my $self = shift;
my $c = shift;
bless $c;
}

1;


foo.pl
use Hoge;
use strict;

my $c = Hoge->new({a=>1,b=>2});
print $c->{'a'};

結果:
1

new の引数に、ハッシュへのリファレンスを渡している。
こいつを bless に渡す。 blessから返ってきたリファレンスを使って、
僕らは、Hogeパッケージの関数を呼び出せるのは以前見た。

いま、このblessから、返ってきたものはいったいどうなっているのだろうか。
$c を Dumper で覗いてみよう。

foo.pl
use Hoge;
use strict;
use Data::Dumper;

my $c = Hoge->new({a=>1,b=>2});
print Dumper $c;

結果:
$VAR1 = bless( {
'a' => 1,
'b' => 2
}, 'Hoge' );

おお!、 aが1でbが2ではいか!!
そう、これは先ほど new に与えたハッシュへのリファレンスである。

blessしたおかげで、new に与えたハッシュへのリファレンスは、
Hogeパッケージのあらゆる関数を呼べるハッシュへのリファレンスに昇格したんだ。

イメージとしては、 { a => 1, b => 2} が Hogeに紐づいた感じ。


しかし、これでは、困ったぞ。
aが1で、bが2であるという情報は、$c が持っているではないか。
つまり、この情報は、foo.pl にしかないではないか。

いや、ここで思い出さなければならいことがある。
○->関数名()
と書いたとき、第1引数には ○ が入ることを。
つまり、
$c->関数名()
と書いた場合、関数の第1引数には $c が渡る。

この知識を使えば、Hoge側で aの値とbの値を足し算することも可能となるではないか。
ソースで見てみよう。

Hoge.pm
package Hoge;
use strict;
use Data::Dumper;

sub new {
my $self = shift;
my $c = shift;
bless $c;
}

sub add {
my $c = shift;
return $c->{a} + $c->{b};
}

1;


foo.pl
use Hoge;
use strict;
use Data::Dumper;

my $c = Hoge->new({a=>1,b=>2});
print $c->add();

結果:
3


このように、第1引数をうまく使うことで、オブジェクトの変数(オブジェクトの変数のように見える変数)にアクセスするのである。


これが、Perlのオブジェクト指向の書き方である。

言語にクラスが備わってなかった。
そこでパッケージをクラスに見たてることにPerlはしたんだ。
Haskellで遊んでみる part3
f x = x+1 
m x = x*3

main = do
print $ m $ f 1
(print . m . f) 1

結果:
6
6
Haskell を Perlで書いてみる
Haskell
f 0 = 1 
f x = x * f (x-1)

main = print $ f 5


Perl
sub f{ return   1                  if $_[0] == 0;
return $_[0] * f($_[0] - 1) if $_[0] != 0;
}

print f(5);

Perlでのオブジェクト指向を書くのに必要な前知識
[知っておかないといけないこと]
bless はリファレンスを返す。
bless には何かのリファレンスを渡す。
デフォルトパッケージは main という名前である。

では、次のソースを見てみよう。
foo.pl
use strict;
use Data::Dumper;

my $c = bless {};
print Dumper $c;

結果:
$VAR1 = bless( {}, 'main' );

blessの第二引数に何も指定しなかったので、
今いるパッケージ(main)が補われている。
さて、このblessから返ってきたリファレンスなのだが、こいつはもうmainのあらゆる関数を呼び出すことができる。

どうやって呼び出すのか、ソースを見てみよう。

foo.pl
use strict;

my $c = bless {};

$c->say_a();
$c->say_b();

sub say_a {
print 'a' . "\n";
}

sub say_b {
print 'b' . "\n";
}

結果:
a
b


では一歩押し進めて、別のファイルにパッケージを作ってみよう。

Hoge.pm (パッケージ名はHogeとした)
package Hoge;
use strict;
use warnings;

sub new {
bless {};
}

sub say_H {
print '僕は、ほげだ' . "\n";
}

1;

このHoge.pmを別のファイルから使ってみる。

foo.pl
use Hoge;
use strict;

my $c = Hoge->new();
$c->say_H();

foo.plを実行した結果:
僕は、ほげだ

Hoge->new()という書き方で、Hogeパッケージの sub new { 略 } を呼べる。
ということは、blessの戻り値をもらえる。
というとこは、そいつで、Hogeパッケージのあらゆる関数を呼び出せる。
という仕組みになってます。


ここで、ちょっと sub new { 略 } の第1引数を見てみよう。

Hoge.pm
package Hoge;
use strict;
use warnings;

sub new {
my $c = shift;
print "$c" . "\n";
bless {};
}

1;


foo.pl
use Hoge;
use strict;

my $c = Hoge->new();

foo.plを実行した結果:
Hoge


さて、では、say_H { 略 } の第1引数はどうなってるのだろう。
次のソースを試してみよう。

Hoge.pm
package Hoge;
use strict;
use warnings;
use Data::Dumper;

sub new {
bless {};
}

sub say_H {
my $c = shift;
print Dumper $c;
print '僕は、ほげだ' . "\n";
}

1;


foo.pl
use Hoge;
use strict;

my $c = Hoge->new();
$c->say_H();

foo.plを実行した結果:
$VAR1 = bless( {}, 'Hoge' );
僕は、ほげだ

つまり、 ○->関数名()  という形で関数を呼ぶと、 ->の左の部分が、
関数の第1引数になります。
Haskellで遊んでみる part2
main = do
print $ f 1
print $ h 2
print $ m 2 $ n $ 3

f x = x+r where r = 1
h x = let r=3 in x+r

m x = (\y->x*y)
n x = x+2

結果:
2
5
10


今度は、 >>=  がわからん~~
ちょっとPerlで遊んでみよう。 part4
 print ((sub { my $c = shift; sub { $d = shift; $c+$d+1; } })->(1)->(2));

ん~~~
今日、こんな感じのソースをみた。
use strict;
use Data::Dumper;

my $c;
@$c{qw(a b)} = ();

print Dumper $c;

結果は、
$VAR1 = {
'a' => undef,
'b' => undef
};


理由は次のものだと思われる..................
http://blog.livedoor.jp/dankogai/archives/50936712.html
Haskellで遊んでみる
main = print ( (\x y -> x+y) ( (\x -> x+1) 1) ( (\y -> y+2) 3 ))

結果:
7


main = print $ f 1 2
f = \x y -> x+y

結果:
3


うむ。無名関数の書き方はわかったけど。
$ がいまいちつかめん。

\で始めれば無名っぽい。






ちなみに、
これだと、
main = f $ (\x -> x+1) 1

f 0 = print 0
f 1 = print 1
f o = print 2

o x = x+1

結果:
2


main = f $ (\x -> x+1) 1

f 0 = print 0
f 1 = print 1
f (\x -> x+1) = print 2

こうは、書けないんだ..........

遅延学習というやつ
なにやらどこかの界隈で「遅延学習」という言葉を聞くようになっていたのだが、
これの意味がやっとわかった。

必要なときに、必要な勉強をするという意味らしい。
プログラム界隈には、「遅延評価」というやつがあって、これの意味は、
必要なときに、評価しまっせ。という意味らしい。

http://blog.livedoor.jp/dankogai/archives/50996734.html


ということで、
$c = sub { 1+1 };

print 'あとでね' . "\n";

print 'いま必要っす!!' . "\n";
print $c->();

あとでね
いま必要っす!!
2

こういうことのようだ。
Perlで遊んでみよう part3
my $q = ( sub {
my $c = 1;
return sub { my $d = shift; $c=$d+$c*2; }
})->();

print $q->($_) . "\n" for 1..3;


3
8
19
ブログ検索

プロフィール

ビンゴ中西
Perlが好きである。
プログラミング言語のほとんどは独学。独学の過程で多くのプログラム仲間にも色々教わりました。

FC2カウンター

カレンダー

06 | 2008/07 | 08
- - 1 2 3 4 5
6 7 8 9 10 11 12
13 14 15 16 17 18 19
20 21 22 23 24 25 26
27 28 29 30 31 - -

ブロとも申請フォーム

この人とブロともになる

| ホーム |
上記広告は1ヶ月以上更新のないブログに表示されています。新しい記事を書くことで広告を消せます。