Code.ge Blog

STL: Simple Template Language Preview

იოსები — Wed, 02 Dec 2009 08:41:15 +0000

დიდი ხნის პაუზის შემდეგ მინდა წარმოგიდგინოთ ერთი ახალი პროექტი რომელზეც გარკვეული პერიოდია ვმუშაობ. ჯერჯერობით ეს არის პრივიუ რელიზი რომელიც მალე საბოლოო ფაზაში შევა და სრულ დოკუმენტაციასა და მაგალითებს შესაბამისად წარმოგიდგენთ. მანამდე კი მისი ნახვა და გადმოწერა შეგიძლიათ შემდეგი მისამართიდან: STL Library.

რა არის STL? როგორც სათაურმა მიგანიშნათ ეს არის PHP – ზე დაწერილი მარტივი და მოქნილი შაბლონების ენა და ამ ენის პროცესორი. STL არის მარტივად გამოყენებადი შაბლონების ენა რომელიც არის საკმაოდ მარტივად ასათვისებელი თუ თქვენ გაგაჩნიათ ნებისმიერ მსგავს შაბლონების ენასთან სულ მცირედი მუშაობის გამოცდილებაც კი. მისი სინტაქსი წააგავს Django, Jinja2, Smarty და სხვა მსგავსი შაბნოლენბის ენებს.

ბიბლიოთეკას არ აქვს არანაირი დამოკიდებულება სხვა გარე ბიბლიოთეკებზე და PHP – ს სპეციფიურ მოდულებზე. კი არის სრულად ე.წ. standalone და მისი გამოყენება შეგიძლიათ ნებისმიერ PHP პროექტში.

რა არის საჭირო მისი გამოყენებისთვის? სულ მცირედი: 1) თქვენს პროექტში უნდა ჩატვირთოთ stl.lib.php რომლის გადაწერაც შეგიძლიათ ზემოთ მითითებული მისამართიდან; 2) შექმნათ შაბლონი ნებისმიერ ტექსტურ ფორმატში(html, txt, xml და ა.შ); 3) შექმნათ STL_template კლასის ობიექტი, გადასცეთ მას საჭირო ტექსტური შაბლონი და კონტესტური ცვლადები და შეასრულოთ. სულ ეს არის და ეს. როგორ? მაგალითი იხილეთ ქვემოთ:

HTML შაბლონი – test.html

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

{if students}
<h1>This is students list</h1>
<ul>
{for student in students}
<li>
<h2>{fn:ucfirst(strtolower(%student.name%))}</h2>
<ul>
{for friend in student.friends}
<li>%friend.name%</li>
{/for}
</ul>
</li>
{/for}
</ul>
{else}
<h1>The students list is empty :(</h1>
{/if}

ნაჩვენები შაბლონის მეშვეობით ხდება სტუდენტებისა და შესაბამისად ცალკეული სტუდენტის მეგობრების სიის გამობეჭდვა. ქვემოთ ნაჩვენებია შაბლონის ინიციალიზაციის კოდი:

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
32
33
34

//შაბლონის ობიექტის შექმნა
$tpl = new STL_template('test.html', true);

//შაბლონში მონაცემების დამატება
$tpl->put('students', array(
array(
'name' => 'John',
'friends' => array(
array(
'name' => 'Ann'
),
array(
'name' => 'Suzan'
),
array(
'name' => 'Tom'
)
)
),
array(
'name' => 'Tom',
'friends' => array(
array(
'name' => 'David'
),
array(
'name' => 'Mary'
)
)
)
));

//შაბლონის პროცესინგი, შესრულება და გამობეჭდვა
echo $tpl->process();

ნაჩვენები კოდის შესრულების შედეგად მიიღებთ სურათზე ნაჩვენებ შედეგს:

რაც შეეხება თავად ენის სინტაქსს როგორც მაგალითიდან ჩანს იგი საკმაოდ მარტივია, თუმცა ყურადღებას შეფაჩერებ რამდენიმე დეტალზე.

if/elseif/else ოპერატორი
ეს არის ერთერთი ყველაზე ხშირად გამოყენებადი ოპერატორი და შესაბამისად მაქსიმუმი გავაკეთე იმისთვის რომ მისი გამოყენება მაქსიმალურად ეფექტურად იყოს შესაძლებელი. მაგალითში ნაჩვენები კოდის ფრაგმენტი “{if students}” უბრალოდ ამოწმებს არის თუ არა აღწერილი ცვლადი სახელით “students” და აქვს თუ არა მას მინიჭებული საწყისი მნიშვნელობა. თუმცა პირობა შესაძლებელია იყოს გაცილებით უფრო კომპლექსური. ქვემოთ ნაჩვენებია ამ ოპერატორის გამოყენების ნიმუშები:

1
2
3
4
5
6
7

{if students && someOtherVariable=="some test value" || testValue in someCollection}
Do something
{elseif !students && !someOtherVariable}
Do something else
{else}
UPS :D
{/if}

გარდა if/elseif/else ოპერატორისა ასევე შეგიძლიათ პოპულარული და უმნიშვნელოვანი foreach ოპერატორის გამოყენება, მაგ:

1
2
3

{for student in students}
%student.name%
{/for}

ნაჩვენებ მაგალითში მოხდება “students” კოლექციის იტერაცია ხოლო ყოველი მომდევნო ელემენტის ახალ “student” ცვლადზე მინიჭება. მოგვიანებით კი შეგიძლიათ ახალი “student” ობიექტისა და მისი თვისებების გამოყენება.

ცვლადების გამობეჭდვა ხდება სპეციალური ფორმატის მეშვეობით, კერძოდ კი ცვლადი უნდა განათავსოთ პროცენტის(%) სიმბოლოებში.

ამ მომენტისათვის ასევე უკვე არსებობს ფუნქციების გამოძახების საშუალება, მაგალითში ნჩვენები ფრაგმენტი:

1	{fn:ucfirst(strtolower(%student.name%))}

ფრაგმენტიდან ჩანს რომ ხდება ორი ფუნქციის გამოძახება: 1) strtolower() PHP ფუნქცია რომელიც მნიშვნელობას გადაიყვანს ქვედა რეგისტრის სიმბოლოებში; 2) ucfirst PHP ფუნქცია რომელიც სტრიქონის პირველ სიმბოლოს გადაიყვანს ზედა რეგისტრის სიმბოლოში.

ასევე STL – ს აქვს მოდულების მხარდაჭერა თუმცა ამაზე ოდნავ მოგვიანებით შეგატყობინებთ პროექტის დარელიზების შემდეგ.

ამ მომენტისათვის სულ ეს არის, დოკუმენტაციასა და უფრო ვრცელ მაგალითებს შემოგთავაზებთ სულ მალე

Google Code Jam 2009 და ქართველი ფინალისტი!

იოსები — Sat, 14 Nov 2009 11:03:04 +0000

მაშ ასე დასრულდა Google Code Jam 2009. წლევანდელი წელი იმით იყო აღსანიშნავი, რომ, 25 ფინალისტს შორის მოხვდა ქართველი პროგრამისტი ნიკა ჯიმშელეიშვილი.

პირველ რიგში თავად ეს ფაქტი იმსახურებს დიდი ყურადღებას და უდავოდ დიდი წარმატებაა, თუმცა, კიდევ ერთი სასიამოვნო ფაქტი არის ის რომ გუშინ შედგა ეს ფინალი და ნიკა მეექვსე ადგილზე გავიდა! ეს ჩემის აზრით ძალიან ძალიან ძალიან მნიშვნელოვანი ფაქტი იმსახურებს სათანადო ყურადღებასა და დაფასებას. ვულოცავ ამ უზარმაზარ წარმატებას ნიკას და ვუსურვებ სხვა უფრო ბრწყინვალე გამარჯვებებს ამ სფეროში და არა მარტო!

კიდევ ერთხელ ვულოცავ ნიკას!

იხ: წლევანდელი ფინალის რეზულტატები

WebKit Patch: ჩემი მცირე წვლილი ბრაუზერების განვითარების ისტორიაში

იოსები — Tue, 13 Oct 2009 09:55:11 +0000

რამდენიმე თვის წინ აღმოვაჩინე რომ FireFox – ის მორიგ განახლებაში დაუმატებიათ ახალი ფუნქციონალობა. კერძოდ კი JavaScript – ის String ობიექტს დაამატეს trim(), trimLeft() და trimRight() მეთოდები. ნებისმიერი პროგრამისტისთვის ცნობილია ამ მეთოდების დანიშნულება და მათი აუცილებლობა სტრიქონული ტიპის მონაცემებთან სამუშაოდ, შესაბამისად არც მე შეგაწყენთ მათი დეტალური განხილვით თავს

ECMAScript 5 სპეციფიკაციში განსაზღვრულია ახალი trim() მეთოდი, თუმცა Mozilla – ს გუნდი უფრო შორს წავიდა და დაამატა ორი ახალი, არასტანდარტული მეთოდი: trimLeft() და trimRight().

ამ მეთოდების აღმოჩენისა და გარჩევის შემდეგ შევეცადე მეპოვნა იგივე მეთოდები სხვა ბრაუზერებში და აღმოვაჩინე, რომ, იმ მომენტისათვის სხვა არცერთ ბრაუზერში მსგავსი რამ არ არსებობდა მათ შორის არც WebKit – ზე დაფუძნებულ ბრაუზერებში(Safari, Chrome). გამომდინარე იქედან რომ WebKit მიმაჩნია საუკეთესო ბირთვად დავინტერესდი შევძლებდი თუ არა ჩემით მსგავსი ფუნქციონალობის რეალიზებას. რამდენიმე საათიანი წვალების შემდეგ მივაღწიე იმას რომ უკვე ხელთ მქონდა WebKit – ის ე.წ. custom build რომელიც აღჭურვილი იყო მოზილას მსგავსი ფუნქციონალობით.

ამ ფაქტით გამხნევებულმა გავარჩიე დოკუმენტაცია მოვამზადე პატჩი და გავუგზავნე WebKit – ის გუნდს. რა თქმა უნდა ამ ფაქტს მოყვა შესაბამისი განხილვა და კოდის უამრავი მოდიფიკაცია, საბოლოო ჯამში მივიღეთ სრულებით სახეცვლილი კოდი რომელიც რამდენიმე თვის დაგვიანების შემდეგ როგორც იქნა ჩადეს WebKit – ის ძირითად კოდში. მართალია ჩემი უყურადღებობისა თუ სხვა მიზეზების გამო კოდის ამ განახლებაში ჩემი სახელი და გვარი არ ფიგურირებს თუმცა ცვლილებას თნ აქვს დართული მთელი დისკუსია შესაბამისი კოდებით რაც მაძლევს იმის თქმის უფლებას რომ WebKit – ში ამ ფუნქციონალობის დამატება ჩემი დამსახურებაა და ნამდვილად არ მეთაკილება ამის თქმა

ამ ფაქტმა ძალიან გამახარა იმიტომ, რომ, აქედან მოყოლებული ნებისმიერი ბრაუზერი რომელიც იყენებს აღნიშნულ ბირთვს(Safari, Chrome, iPhone Safari, Android Browser და სხვა) ყველა აღჭურვილი იქნება იმ ფუნქციონალობით რომელშიც წვლილი მიმიძღვის, ჩემთვის როგორც დეველოპერისთვის ეს ფაქტი ძალიან მნიშვნელოვანია და იმედია არ დამზრახავთ ამ სიხარულისთვის!

კოდში შეტანილი ცვლილებები: http://trac.webkit.org/changeset/49423
დისკუსია პატჩის გარშემო: https://bugs.webkit.org/show_bug.cgi?id=26590
WebKit – ის ბილდი აღწერილი ფუნქციონალობით: http://nightly.webkit.org/

Code.ge Presents: Internet Explorer 6 Must Die!

იოსები — Sun, 27 Sep 2009 10:17:57 +0000

კიდევ ერთხელ მოგესალმებით ყველას. ამჯერად წარმოგიდგენთ ერთ მინი პროექტს რომლის განცხორციელებაც დაგეგმილი მქონდა გასული წლის დეკემბერში მაგრამ გარკვეულ თუ გაურკვეველ მიზეზთა გამო ვერ გამოვნახო სულ რამდენიმე საათი რათა ამ იდეისთვის ხორცი შემესხა . თუმცა რამდენიმე დღის წინ არსაიდან აღმოცენებულმა Google – ს პროექტმა Chrome Frame კვლავ გამიღვიძა ამის სურვილი.

პროექტი Internet Explorer 6 Must Die! მიმართულია ინტერნეტის მომხმარებელთა შორის Internet Explorer 6.0 – ის შემცირებისა და ამ ბრაუზერის სიკვდილის( ) დასაჩქარებლად. მიუხედავად ყველაფაფრისა ამ ბრაუზერს ინტერნეტ ბაზრის 25% უკავია რაც ყოვლად დაუშვებელი და მიუღებელია, მითუფრო რომ Microsoft – მა ბოლო წლების მანძილზე გამოუშვა ორი, გაცილებით უკეთესი ბრაუზერი Internet Explorer 7 და Internet Explorer 8.

Internet Explorer 6 Must Die! არის მცირე ზომის სკრიპტი, რომელიც უნდა ჩასვათ თქვენს ვებ გვერდში. ხოლო თუ მომხმარებელი თქვენს გვერდს გახსნის Internet Explorer 6 – ის მეშვეობით დაინახავს მსგავს შეტყობინებას:

ნაჩვენები შეტყობინება მთლიანად დაფარავს გვერდს ისე რომ მომხმარეელი მხოლოდ გამჭვირვალე ფონის მიღმა შეძლებს გვერდის კონტენტის დანახავს. მომხმარებელს შეუძლია არჩევანი გააკეთოს და ძირითადი 6 ბრაუზერიდან აირჩიოს ერთერთი.

ჩემის აზრით თითოეული ჩვენგანის აქტიურობა და მცდელობა იმისა რომ თუნდაც რამდენიმე ერთეულით შევამციროთ Internet Explorer 6 გარკვეული დროის შემდეგ მნიშნველოვან შედეგს გამოიღებს. ეს კი პირველ რიგში იმ ადამიანებისთვის არის მნიშნვნელოვანი რომლებიც ქმნიან ვებ საიტებს/აპლიკაციებს და რომლებიც უამრავ დროს ხარჯავენ Internet Explorer 6 – თან გაუთავებელ ბრძოლაში.

პროექტის საწყისი კოდი განთავსებულია GitHUB – ზე. მისი გამოყენებისათვის საკმარისია გადმოწეროთ სკრიპტის ბოლო ვერსიის zip არქივი შემდეგი მისამართიდან: http://github.com/ioseb/ie6mustdie/downloads.
გახსნათ არქივი თქვენთვის სასურველ დირექტორიაში ხოლო თქვენს ვებ გვერდში BODY ტეგის დახურვამდე მიუთითოთ შემდეგი JavaScript კოდი:

1	<script type="text/javascript" src="path/to/ie6mustdiefolder/ie6mustdie.js"></script>

დანარჩენს კი სკრიპტი თავად გააკეთებს!

LinGEO – Now on iTunes!

იოსები — Sat, 26 Sep 2009 09:33:31 +0000

აღესრულა! დღეს დილიდან ლაშამ ძალიან კარგი ამბავი შემატყობინა, ჩვენმა აპლიკაციამ Apple – ს კაბალური შემოწმების პროცესი წარმატებით გაიარა და დღეიდან უკვე LinGEO ოფიციალურად არის დამატებული Apple AppStore – ში, შესაბამისად ვისაც გაქვთ iTunes ანგარიში თამამად შეგიძლიათ გადმოწეროთ აპლიკაცია და დააინსტალიროთ თქვენს iPhone – ზე. კიდევ ერთხელ განასკუთრებული მადლობა ლაშას აპლიკაციის დასრულებისა და მისი გაუმჯობესებისათვის, ასევე იმ რთული პროცესის წარმატებით გავლისათვის რასაც აპლიკაციის AppStore – ში განთავსებას ახლავს თან! ასევე დიდი მადლობა Toto – ს შესანიშნავი რჩევებისა და გაუმჯობესებებისათვის და გიორგი(Flyer) კვიჟინაძეს ლოგოს შექმნისათვის!

Google Chrome Frame

იოსები — Fri, 25 Sep 2009 09:41:03 +0000

რამდენიმე დღის წინ Google – მ გაახმაურა თავისი ახალი პროექტი სახელად Google Chrome Frame. ეს არის პლაგინი InternetExplorer – ისთვის რომელის ინსტალაციის შემდეგაც საიტები თუ მათ გააჩნიათ შესაბამისი META ტეგი, ჩაიტვირთებიან არა IE – ს ძრავის არამედ Google Chrome – ს ძრავის მეშვეობით. ეს ნიშნავს იმას რომ ყოველგვარი არათავსებადობის პრობლემა(რომელსაც 99% შემთხვევებში იწვევს IE) საერთოდ აღარ შეაწუხებს მომხმარებელს. როგორც აღმოჩნდა გუგლის ეს ნაბიჯი განპირობებული იყო მისი ახალი პროდუქტის – Google Wave გამო რომელიც ხელმისაწვდომი მომავალი კვირიდან გახდება. საინტერესო არის ის, რომ, გუგლმა IE – ს ყველა ვერსიის მხარდაჭერაზე განაცხადა უარი რადგანც ამ ბრაუზერებს არ აქვთ JavaScript – ისა და HTML5 – ის ახალი შესაძლებლობების მხარდაჭერა.

მაგრამ Wave – ს გამო შექმნილი პლაგინის გაოყენებაში არანაირად არ ვართ შეზღუდული და იგი შეგვიძლია გამოვიყენოთ ნებისმიერი ვებ საიტისთვის, რისი მაგალითიც არის ჩემი ბლოგი თუ ამ გვერდს გახსნით IE6 – ის მეშვეობით მაშინათვე დაინახავთ Google Chrome Frame – ს ინსტალაციის შემოთავაზებას და იმ შემთხვევაში თუ დააინსტალირებთ პლაგინს თქვენს კომპზე არსებული IE6, IE7 და IE8 ავტომატურად იმუშავებს Chrome Frame რეჟიმში

ტექნიკურად ეს საკითხე გვარდება ძალიან მარტივად. პირველ რიგში საიტის HEAD სექციაში უნდა დავამატოთ შემდეგი META ტეგი:

1	<meta http-equiv="X-UA-Compatible" content="chrome=1" />

თუ Google Chrome პლაგინი უკვე დაინსტალირებული აქვს მომხმარებელს ყველა ვერსიის IE იმუშავებს Google Chrome – ს ძრავით ისე რომ ამის შესახებ მომხმარებელს არაფერი ეცოდინება.

იმისათვის რომ მომხმარებელს შევთავაზოთ პლაგინის ინსტალაცია, ასევე საჭიროა ვებ გვერდში შემდეგი კოდის ჩასმა(გაუგებრობების თავიდან ასარიდებლად BODY ტეგის დახურვამდე):

1
2
3
4
5
6
7
8
9
10
11

ეს სკრიპტი შეამოწმებს აქვს თუ არა მომხმარებელს დაინსტალირებული ნახსენები პლაგინი, და თუ არა მაშინ შესაბამისი შეტყობინება შესთავაზებს მომხმარებელს მის ინსტალაციას.

შედეგი? შედეგი კი ძალიან საინტერესოა. რა თქმა უნდა ვერ შევიკავე თავი და გავტესტე პლაგინი ჩემს ბლოგზე და შედეგიც სახეზეა:

თუ გახსნით ბოლო სურათს, დაინახავთ რომ ბლოგის მარჯვენა სვეტში განთავსებულ პროექტების ბანერებს მომრგვალებული კუთხეები აქვთ, ეს მომრგვალება გაკეთებულია CSS – ის border-radius თვისების მეშვეობით რომლის მსგავსიც არცერთ IE – ს არ გააჩნია

Enjoy

LinGEO ინგლისურ/ქართული ლექსიკონი iPhone – სთვის

იოსები — Tue, 22 Sep 2009 15:49:27 +0000

როგორც იქნა ერთ წლიანი პაუზის შემდეგ ჩემს მიერ დაწყებულმა და შემდგომ მიტოვებულმა პროექტმა – LinGEO შეიძინა პროდუქტის სახე და ახლა უკვე მომხმარებლებს შეუძლიათ მისით სარგებლობა.

პირველად ეს პროექტი გავახმაური ერთი წლის წინ როდესაც მას ჯერ კიდევ ერქვა LinGO, მას შემდეგ ვეღარ გამოვნახე შესაბამისი რესურსი რომ მიმეყვანა ეს პროექტი ბოლომდე. სულ ახლახანს როდესაც კვლავ გადავწყვიტე აქტიური ბლოგერობა და ზოგადად ოპენ სორს პროექტებზე მუშაობის გაგრძელება, გავხსენი ამ პროექტის საწყისი კოდიც(იხ. LinGEO on GitHUB). ამის მიზეზი ერთის მხრივ იყო ჩემი სურვლი რომ დამესრულებინა პროექტი, ხოლო მეორეს მხრივ ჩემი კოლეგისა და მეგობრის ლაშა დოლიძის დაინტერესება.

კოდის გახსნიდან სულ რაღაც სამი კვირის შემდეგ სახეზე გვაქვს უკვე დასრულებული პროექტი. ამისათვის განსაკუთრებულ მადლობას ვუხდი ლაშას რომლის უშუალო დამსახურებაც არის ამ პროექტის საბოლოო პროდუქტად ქცევა. გარდა უმნიშვნელოვანესი პროგრამული დეტალების დახვეწისა მან განათავსა პროდქუტი Apple – ს App Store – ში(პროგრამა ამჯერად მოლოდინის რეჟიმშია და ველით დასტურს), ასევე შექმნა Cydia – ს რეპოზიტორი არაოფიციალური iPhone – ს მომხმარებელთათვის.

ასევე მინდა მადლობა გადავუხადო Toto – ს შესანიშნავი კომენტარებისა და შენიშნვებისათვის რომელიც გააკეთა ამ პროდუქტთან დაკავშირებით.

Java: variables, stack and heap

იოსები — Tue, 22 Sep 2009 07:03:59 +0000

პრეზენტაცია Java – ს ცვლადების და მათთან დაკავშირებული საკითხების შესახებ.

JavaScript: String.replace()

იოსები — Wed, 16 Sep 2009 20:27:52 +0000

რამდენიმე წლის წინ დავწერე პოსტი JavaScript – ით DOM ელემენტის სტილებთან მუშაობის შესახებ. ბრაუზერებს შორის სხვაობიდან გამომდინარე(კერძოდ კი IE – ს განსხვავებული მიდგომის გამო) პრობლემის გვერდის ასავლელად დავწერე ქვემოთ ნაჩვენები კოდი:

1
2
3
4
5
6
7
8
9
10

კოდის ერთადერთი დანიშნულებაა ტირეებიანი CSS ატრიბუტების მაგ. border-left-color, background-color გადაყვანა ე.წ. Camel Case ფორმატში ანუ borderLeftColor, backgroundColor და ა.შ.

დღეს კოდის წერისას იგივე პრობლემა მექანიკურად გადავჭერი სხვა უფრო მოხდენილი და რაც მთავარია გაცილებით მცირე ზომის კოდის მეშვეობით:

1
2
3
4
5
6
7
8

var str = "some-test-string";
str.replace(/-([\w])/gi, function(a1, a2) {
return a2.toUpperCase();
});

//კოდის შესრულების შემდეგ
//სტრიქონი "some-test-string"
//გარდაიქმნება შემდეგნაირად: "someTestString"

დამეთანხმებით რომ თვალსაჩინო სხვაობაა როგორ მუშაობს ეს კოდი? პირველ რიგში შეგახსენებთ თავად String ობიექტის replace() მეთოდის სიგნატურას:

str.replace(regexp|substr, newSubStr|function[, Non-standard flags]);

ანუ replace() მეთოდს მეორე პარამეტრად ახალი, ჩასანაცვლებელი სტრიქონის ნაცვლად შეგვიძლია გადავცეთ ქოლბექ ფუნქცია რომელიც დააბრუნებს დამუშავებულ სტრიქონს, ხოლო ეს დაბრუნებული სტრიქონი თავის მხრივ გამოყენებული იქნება რეგულარული გამოსახულების მიერ ნაპოვნი შესატყვისის ჩასანაცვლებლად.

საინტერესოა ასევე თუ რა პარამეტრებს გადასცემს replace() მეთოდი ქოლბექ ფუნქციას. გადასაცემი პარამეტრების რაოდენობა ცვალებადია და დამოკიდებულია მთელ რიგ ფაქტორებზე. მაგალითად ჩემს მიერ ნაჩვენებ მაგალითში ფუნქციას გადაეცემა ოთხი პარამეტრი, კერძოდ კი ფუნქცია გამოიძახება ორჯერ შემდეგი პარამეტრებით:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

//პიველი დამთხვევისათვის ანუ "-t"
function(
"-t", //რეგულარული გამოსახულების მიერ ნაპოვნი სტრიქონი სრულად
"t", //დამაჯგუფებელ ფრჩხილებში მოთავსებული შედეგი
4, //პოზიცია რომელზეც მოხდა პირველი დამთხვევა
"some-test-string" //სრული სტრიქონი
);

//მეორე დამთხვევისათვის ანუ "-s"
function(
"-s", //რეგულარული გამოსახულების მიერ ნაპოვნი სტრიქონი სრულად
"s", //დამაჯგუფებელ ფრჩხილებში მოთავსებული შედეგი
9, //პოზიცია რომელზეც მოხდა პირველი დამთხვევა
"some-test-string" //სრული სტრიქონი
);

ნაჩვენები კოდიდან თვალსაჩინოა სავარაუდო პარამეტრების რაოდენობა, თუმცა მნიშვნელოვანია შემდეგი დეტალების გათვალისწინება, ქოლბექ ფუნქციას:

პირველ პარამეტრად ყოველთვის გადაეცემა რეგულარული გამოსახულების მიერ ნაპოვნი სრული შესატყვისი;
ბოლო პარამეტრად ყოველთვის გადაეცემა სრული სტრიქონი რომლშიც განხორციელდა გარკვეული შესატყვისის ძიება;
ბოლოდან მეორე(ბოლოს წინა) პარამეტრად ყოველთვის გადაეცემა ნაპოვნი შესატყვისის პოზიცია.
თუ რამდენი პარამეტრის გადაცემა მოხდება პირველსა და ბოლო ორ პარამეტრს შორის დამოკიდებულია რეგულარულ გამოსახულებაში გამოყენებული დამაჯგუფებელი ფრჩხილების რაოდენობაზე(ჩემს მიერ ნაჩვენებ მაგალითში ასეთი პარამეტრი ერთია რადგან მხოლოდ ერთი დამაჯგუფება მაქვს გამოყენებული);
replace() მეთოდი გამოიძახებს ერთხელ თუ რეგულარული გამოსახულების ბოლოს არ გვაქვს მითითებული “g” ანუ გლობალური მოდიფიკატორი, ან გამოიძახებს იმდენჯერ რამდენი დამთხვევაც მოხდება კონკრეტული შესატყვისისათვის(ნაჩვენებ მაგალითში გამოძახება მოხდება ორჯერ).

enjoy B-)

jQuery საკუთარი ხელით – ნაწილი 2

იოსები — Fri, 11 Sep 2009 20:38:01 +0000

მაშ ასე, განვაგრძობ პოსტების სერიას “jQuery საკუთარი ხელით” და გთავაზობთ მეორე ნაწილს. პირველ ნაწილში ლაპარაკი გვქონდა ამ ბიბლიოთეკის ძირითად შემადგენელ ნაწილებსა და მისი მუშაობის ზოგად პრინციპებზე. ასევე პირველ ნაწილში შევქმენით ბიბლიოთეკის კარკასი კოდური სახელწოდებით myQuery და სადემონსტრაციოდ დავამატეთ ერთი მეთოდი.

დასაწყისისთვის უკვე გაგვაჩნია საკმარისი ინფორმაცია და მოდულის მკაფიო მონახაზი რომელზე დაყრდონბითაც შეგვიძლია გადავიდეთ რეალიზაციის შემდეგ ნაწილზე. ამ ნაწილში ლაპარაკი მექნება DOM ელემენტის class ატრიბუტსა და მასთან სამუშაო მეთოდებზე.

DOM ელემენტის class ატრიბუტს საკმაოზე უფრო მეტად მნიშვნელოვანი როლი აკისრია და ეს ატრიბუტი განსაკუთრებულ ყურადღებას იმსახურებს. ძირითადად ეს ატრიბუტი DOM ელემენტისათვის CSS კლასების მისანიჭებლად გამოიყენება, თუმცა მინდა აღვნიშნო, რომ, “class” ატრიბუტი არის ზოგადი დანიშნულების ატრიბუტი და არ არის განსაზღვრული მხოლოდ CSS კლასების მისანიჭებლად. ასევე აღსანიშნავია რომ შესაძლებელია DOM ელემენტის ამ ატრიბუტს შესაძლებელია ერთდროულად მივანიჭოთ არის[space] სიმბოლოთი გამოყოფილი ერთზე მეტი კლასი.

ელემენტის აღნიშნული ატრიბუტისათვის მნიშვნელობის მინიჭება და ამ მნიშვნელობის წაკითხვა ხორცილდება DOM ელემენტის className თვისების მეშვეობით. მაგ:

1
2
3
4
5
6
7
8

var el = document.getElementById('element-identifier');
el.className = 'some-css-class';
//ან
el.className = 'some-css-class some-other-class just-class';
//მნიშვნელობის წაკითხვა
var className = el.className;
//კლასის განადგურება
el.className = '';

მიუხედავად იმისა რომ ელემენტის className თვისება შესანიშნავად ართმევს თავს დაკისრებულ მოვალეობას იგი მოუხერხებელია მთელ რიგ შემთხვევებში. კერძოდ კი:

თუ ატრიბუტი შეიცავს კლასების ჩამონათვალს შეუძლებელია მარტივი გზით დავადგინოთ გააჩნია თუ არა ელემენტს ეს თუ ის კონკრეტული კლასი რადგან ამ შემთხვევაში შედარების “==” ოპერატორი უსარგებლოა;
თუ ატრიბუტი შეიცავს კლასების ჩამონათვალს არ არსებობს მარტივი გზა კონკრეტული კლასის მოსაშორებლად;
თუ ატრიბუტი შეიცავს ერთდროულად რამდენიმე კლასს შეუძლებელია რომელიმე კონკრეტულ კლასს შევუცვალოთ პრიორიტეტი(პრიორიტეტი ამ შემთხვევაში ენიჭება უკიდურეს მარჯვენა კლასს);

ასეთი შემთხვევებისათვის jQuery აღჭურვილია რამდენიმე შესანიშნავი მეთოდით რომელიც გამოიყენება ექსკლუზიურად class ატრიბუტთან სამუშაოდ. კერძოდ კი:

addClass – ელემენტისათვის ახალი კლასის დასამატებლად;
hasClass – შესამოწმებლად, გააჩნია თუ არა ელემენტს ესა თუ ის კონკრეტული კლასი;
removeClass – ელემენტისათვის კონკრეტული კლასის მოსაშორებლად;
toggleClass – კლასის “გადასართავად”. იგულისხმება რომ თუ ელემენტს გააჩნია მეთოდისათვის პარამეტრად გადაცემული კლასი მაშინ იგი უნდა მოშორდეს, წინააღმდეგ შემთხვევაში კი დაემატოს ელემენტს.

ჩამოთვლილი მეთოდების რეალიზაცია ძალიან მარტივია. ამისათვის სულ რამდენიმე სტრიქონი კოდია საჭირო:

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

“className” ობიექტი შედგება ოთხი add, has, remove და toggle ზოგადი დანიშნულების მეთოდებისგან და ყოველი მათგანი ღებულობს ორ პარამეტრს – DOM ელემენტი და სასურველი კლასის სახელი. მეთოდები საკმაოდ მარტივია რადგან მუშობა ხდება ჩვეულებრივ სტრიქონთან. თუმცა “add” მეთოდის შემთხვევაში უნდა აღინიშნოს რომ კლასის სახელის დამატება აუცილებლად ხდება ჩამონათვალის ბოლოში რათა გარანტირებული იყოს ახლად დამატებული კლასის პრიორიტეტულობა.

ნაჩვენები className თამამად შეგვიძლია დავამატოთ ჩვენს “myQuery მოდულში ნებისმიერ ადგილას. თუმცა ამ ობიექტის მეთოდები ჯერჯერობით უხილავი იქნება გარე სამყაროსთვის, ამისათვის საჭიროა თავად myQuery მოდულის prototype სექციაში დავამატოთ შესაბამისი API მეთოდები რომლის მეშვეობითაც მოხდება ახლად რეალიზებული მეთოდების გამოძახება. რეალიზაცია:

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

myQuery.prototype = {

//other methds

addClass: function(name) {
this.each(function() {
className.add(this, name);
});
return this;
},

hasClass: function(name) {
return this[0] ? className(this[0], name) : false;
},

removeClass: function(name) {
this.each(function() {
className.remove(this, name);
});
return this;
},

toggleClass: function(name) {
this.each(function() {
className.toggle(this, name);
});
return this;
}

}

როგორც ხედავთ რეალიზაცია ძალიან მარტივია, თუმცა რამდენიმე დეტალს უფრო ვრცლას შევეხები. პირველ რიგში ყუარდღება მიაქციეთ რომ hacClass მეთოდის გარდა ყველა მეთოდი თავის შესაბამის ოპერაციას ახორციელებს მიმდინარე myQuery ობიექტის მიერ ნაპოვნ ყველა DOM ელემენტზე. მეორე რიგში ყურადღებას იმსახურებს თავად each() მეთოდის გამოყენება რომლის რეალიზაციაც გავაკეთეთ პოსტის პირველ ნაწილში. საინტერესოა ის რომ ელემენტების იტერაციისათვის გამოვიყენეთ თავად მოდულის ჩვენს მიერ რეალიზებული API მეთოდი და არა ტრადიციულად ციკლის ოპერატორი. და ასევე ყურადღება მიაქციეთ რომ ყველა მეთოდი(კვლავ hasClass მეთოდის გარდა) აბრუნებს მიმდინარე myQuery ობიექტს, ცხადია ეს აუცილებელია ჯაჭვურობის შესანარჩუნებლად.

ახლად დამატებული მეთოდების მეშვეობით უკვე შესაძლებელია საკმაოდ საინტერესო შედეგების მიღება. მაგალითისათვის გადახედეთ შემდეგ კოდს:

1
2
3
4
5
6
7
8
9

$('div p a') //find all "A" tags within "P" tags
.removeClass('unnecessary-class') //remove class "unnecessary-class"
.addClass('some-new-class') //add class "some-new-class"
.toggleClass('some-other-class') //toggle class "some-other-class"
.each(function() { //iterate through all "A" tags
console.log(this.className); //print class name to the console output
});

var value = $('#element-identifier').hasClass('some-class-of-intereset');

ჩემის აზრით საკმოად შთამბეჭდავი შედეგია არც თუ ისე რთული და მოცულობითი კოდის კვალობაზე

დროა გავაერთიანოთ პოსტის პირველი და მიმდინარე ნაწილის შედეგები:

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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

jQuery საკუთარი ხელით – ნაწილი 1

იოსები — Thu, 10 Sep 2009 11:00:30 +0000

jQuery განეკუთვნება იმ ბიბლიოთეკათა ნაწილს რომელმაც მოახერხა და გულგრილად არ დატოვა მთელი მსოფლიოს ვებ დეველოპერები. ძალიან ბევრი ამ სფეროში მომუშავე პროფესიონალი თუ მოყვარული დამეთანხმება რომ ამ ბიბლიოთეკის ავტორმა ჭეშმარიტად ეფექტურ და უნიკალურ მიდგომას მიაგნო რამაც უთვალავ ვებ პროგრამისტს არათუ უბრალოდ გაუადვილა არამედ მეტი ხალისი და აზარტი შესძინა მათ ყოველდღიურ საქმიანობას.

ამ პოსტით მინდა გავხსნა დაგეგმილი სერია პოსტებისა რომლის მეშვეობითაც შევეცდები გაგაცნოთ jQuery – ს შიდა სამზარეულო და გადმოგცეთ მასში გამოყენებული ძირითადი მიდგომები რომლებიც დაგეხმარებად მსგავსი ტიპის საკუთარი ბიბლიოთეკების შექმნაში.

პოსტის დანარჩენი ნაწილის წაკითხვამდე მინდა გაგაფრთხილოთ რომ ეს არ არის ტუტორიალი jQuery – ს შესწავლის მსურველთათვის, და იგულისხმება რომ თქვენ უკვე გაქვთ ამ ბიბლიოთეკასთან მუშაობის გარკვეული გამოცდილება.

მაშ ასე შევუდგეთ საქმეს!

პირველ რიგში ვიდრე შევუდგებით კოდის წერასა და ქვედა დონის დეტალების განხილვას, მნიშვნელოვანია გამოვყოთ jQuery – ს ის ძირითადი შემადგენელი კომპონენტები.

CSS სელექტორ ენჯინი – ეს არის jQuery – ს უმთავრესი შემადგენელი ნაწილი, რომელსაც მექანიკურად ვეხებით ბიბლიოთეკის პირველივე გამოყენებისთანავე. კერძოდ კი ეს არის ძრავი რომელიც DOM დოკუმენტში CSS 3 – თან თავსებადი სელექტორების მეშვეობით ელემენტების მოძებნის საშუალებას გვაძლევს;
ატრიბუტები – სპეციალური მეთოდები ელემენტების ატრიბუტებთან სამუშაოდ;
ტრავერსინგი – სპეციალური მეთოდები უკვე ნაპოვნი DOM ელემენტების დამატებითი ფილტრაციისა და ნავიგაციისთვის;
ელემენტებით მანიპულაცია – სპეციალური მეთოდები ელემენტებზე სხვადასხვა DOM ოპერაციების ჩასატარებლად(მაგ. წაშლა, ჩამატება, გადატანა, კლონირება);
CSS მანიპულაცია – DOM ელემენტების CSS სტილებთან მუშაობა;
ივენთები – DOM ელემენტების ივენთების მენეჯმენტი;
Ajax – XMLHttpRequest ობიექტის გარშემო აგებული სპეციალური მეთოდები სერვერთან ასინქრონულ რეჟიმში მუშაობისათვის;

ეს არის ნაწილი იმ ძირითადი კომპონტენტებისა რომლისგანაც შედგება jQuery. აღსანიშნავია რომ ყოველი კომპონენტი საკმაოდ კომპლექსურია და ყველა მათგანს გააჩნია მათთვის დამახასიათებელი სირთულეები რაც ძირითადად ბრაუზერებს შორის თავსებადობაში გამოიხატება.

ამ მცირედი შესავლის შემდეგ შეგვიძლია გადავიდეთ საქმეზე და შევუდგედ კოდირებას, თუმცა, მანამდე სანამ დავწერთ კოდს უნდა განვიხილოთ jQuery – ს ორ მაგიურ დეტალს რომელიც თავის თავში აერთიანებს ყველა ზემოთ ჩამოთვლილ კომპონენტს და განსაკუთრებულ ხიბლსა და ელეგანტურობას სძენს მიმდინარე პოსტის გმირს. პირველია ფუნქცია რომლის სახელიც არის დოლარის აღმნიშნველი სიმბოლო:

1
2
3

//ცნობილი დოლარის ნიშანი რომელიც რეალურად
//არის მიმთითებელი გლობალურ jQuery ობიექტზე
$('#dom-element-id');

ხოლო მეორე ე.წ. chaining რომლის მეშვეობითაც ჯაჭვურად შეგვიძლია გამოვიძახოთ სხვადასხვა ტიპის მეთოდები და განვახორციელოთ სხვადასხვა მაინპულაციები CSS მოთხოვნის მიხედვით ნაპოვნ DOM ელემენტების კოლექციაზე:

1
2
3
4
5

$('#dom-element-id') //ვიპოვნოთ ელემენტი იდენტიფიკატორით
.find('li') //ნაპოვნ ელემენტში ვიპოვნოთ ყველა LI ელემენტი
.addClass('found') //ნაპოვნ LI ელემენტებს მივანიჭოთ CSS კლასი
.find('span') //LI ელემენტებში ვიპოვოთ ყველა SPAN ელემენტი
.remove(); //გავანადგუროთ ნაპოვნი SPAN ელემენტები

კოდის ეს ორი მცირე ფრაგმენტი ძალიან მარტივი და ელეგანტურია მითუფრო თუ გავითვალისწინებთ მთელს იმ სირუთელეებს რაც ამ რამდენიმე მეთოდის გამოძახების უკან დგას! მეთოდების ასე ჯაჭვურად გამოძახების შესაძლებლობა

კიდევ ერთი საინტერესო და jQuery – სთვის დამახასიათებელია დეტალი

გიფიქრიათ ოდესმე მსგავსი რამის საკუთარი ხელით შექმნაზე? არა? ან გიფიქრიათ და დაგზარებიათ? თუ მსგავსი რამ ჯერ არ გაგიკეთებიათ ესე იგი უკვე დროა დავიკაპიწოთ ხელები და შევუდგეთ საკუთარი jQuery – ს მსგავსი ბიბლიოთეკის შექმნას. ამ პოსტში და მის შემდგომ ნაწილებში ამ ბიბლიოთეკას პირობითად დავარქვათ myQuery და შევუდგეთ იმპლემენტაციას.

პირველ რიგში გვესაჭიროება “$” ფუნქცია რომელიც წვდომას მოგვცემს myQuery კლასის ობიექტზე. ფუნქცია ძალიან მარტივია, მას გადაეცემა ორი პარამეტრი – CSS სელექტორი და კონტექსტი(არააუცილებელი პარამეტრი). აღწერილი მიზნის მისაღწევად სრულებით საკმარისია ქვემოთ ნაჩვენები კოდი:

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

პირველ რიგში ყურადღებას შევაჩერებ კოდის რამდენიმე დეტალზე. კერძოდ კი ყუარდღებას იმსახურებს შემდეგი კონსტრუქცია:

1
2
3

(function() {

})();

ეს ერთი შეხედვით უცნაური კოდი ექვივალენტურია შემდეგი კოდისა:

1
2
3
4
5
6
7

//ფუნქციის აღწერა
function myFunction() {
//some initialization code here
}

//ფუნქციის გამოძახება
myFunction();

თუმცა ჩვენს შემთხვევაში ტრადიციული გზა მთლიანად ავიცილეთ თავიდან რადგან აბსოლუტურად არაფერში არ გვესაჭიროება დამოუკიდებელი ფუნქციის აღწერა ინიციალიზაციისათვის რადგან ეს ფუნქცია უნდა შესრულდეს მხოლოდ ერთხელ კოდის ჩატვირთვისთანავე და კოდის სხვა ნაწილიდან მისი გამოძახების არანაირი აუცილებლობა არ არსებობს. გარდა ამისა ფუნქციის ავტომატურ გამოძახებასთან ერთად ჩვენი კოდის დანარჩენი ნაწილი მოქცეულია ერთ კონკრეტულ კონტექსტში(კონტექსტი შემოიფარგლება ანონიმური ფუნქციის შიდა კონტექსტით) და არ ხდება გლობალური(window) კონტექსტის დაბინძურება. კოდის დანარჩენი ნაწილი ჩვეულებრივი ფუნქციის აღწერებია და განსაკუთრებულ ახსნა განმარტებას არ იმსახურებს, თუმცა ყოველი შემთხვევისთვის აღვნიშნავ რომ შემდეგი კოდის მეშვეობით:

1	window.$ = function(query, context)

გარდა იმისა რომ “$” ფუნქციას ხელმისაწვდომს ვხდით გლობალურ(window) კონტექსტში, ამ ფუნქციას უნარჩუნდება წვდომა ზემოთ ნახსენები ანონიმური ფუნქციის კონტექსტზე ისე რომ ამ კონტექსტს მიღმა არსებულ სხვა კოდს მასთან არანაირი შეხება არ გააჩნია.

მოცემული კოდის მეშვეობით უკვე შეგვიძლია შევასრულოთ შემდეგი ტიპის გამოძახებები:

1 2	$('div.my-div-class-name a.selected'); $('div.my-div-class-name', document.getElementById('any-element-id'));

თუმცა ცხადია ნაჩვენები კოდი არანაირ რეზულტატს არ მოგვცემს რადგან myQuery ჯერჯერობით არანაირი ფუნქციონალობით არ არის აღჭურვილი. იმისათვის რომ ჩვენმა რეალიზაციამ გააკეთოს რაიმე სასარგებლო პირველ რიგში საჭიროა იგი აღვჭურვოთ ნახსენები CSS სელექტორების ძრავით. საწყის ეტაპზე ამ მიზნის მისაღწევად საკმარისი იქნება თუ ვისარგებლებთ ბოლო ვერსიების(Safari, Chrome, Firefox 3.5, Opera 10, InternetExplorer 8 ) ბრაუზერებში ჩადებული “querySelectorAll” მეთოდით რომლის მეშვეობითაც შესაძლებელი იქნება დოკუმენტისა ან ნებისმიერი DOM ელემენტის კონეტქსტში მოვძებნოთ სხვა DOM ელემენტები CSS სელექტორის გამოყენებით. ამ მეთოდის გამოსაყენებლად საჭიროა myQuery შევცვალოთ შემდეგნაირად:

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
32
33
34
35
36
37
38
39
40
41
42
43

მოდიფიცირებული ფუნქცია საკმაოდ მარტივია. პირველ რიგში იგი querySelectorAll მეთოდისა და ფუქციისათვის პირველ პარამეტრად გადაცემული CSS სელექტორის მეშვეობით კონკრეტულ კონტექსტში ეძებს დომ ელემენტებს. როგორ მუშაობს ეს ფუნქცია?

მე – 4 სტრიქონი – თუ გამოძახება მოხდა კონტექსტის პარამეტრის გარეშე ნაგულისხმევ კონტექსტად გამოიყენება “document” ობიექტი;
7/9 სტრიქონები – ამ შემთხვევაში საჭიროა შევამოწმოთ არის თუ არა კონტექსტი მასივის ტიპის რადგან მსგავსი რამ დასაშვებია. თუ კონტექსტი არ არის მასივი და DOM დოკუმენტი ან DOM ობიექტი ჩავდოთ იგი მასივში და ხელახლა მივანიჭოთ იგი “context” ცვლადს;
17/27 სტრიქონები – ციკლში ყოველი კონტექსტისათვის შევასრულოთ “querySelectorAll” მეთოდი.
35 – ე სტრიქონი – აღვწეროთ ობიექტის “length” თვისება ;

38/40 სტრიქონები – ნაპოვნი DOM ელემენტების დამატება ხდება თავად “myQuery” ობიექტში რაც ნიშნავს იმას რომ მაგ მომენტიდან myQuery ობიექტი შეგვიძლია გამოვიყენოთ როგორც მასივი. მაგალითად ქვემოთ ნაჩვენები ყველა მაგალითი აბსოლუტურად ვალიდურია:

1
2
3
4
5
6
7
8
9

alert($('div')[0]);
//ან
var result = $('div');
alert(result[0]);
//ან
var result = $('div');
for (var i = 0; i < result.length; i++) {
alert(result[i].nodeName);
}

ობიექტის აღჭურვა მასივის მსგავსი ქმედებებით ამ კონკრეტულ შემთხვევაში მიიღწევა Array ობიექტის push მეთოდისა და myQuery ობიექტის “length” თვისების მეშვეობით. ამონარიდი JavaScript – ის დოკუმენტაციიდან:

push is intentionally generic. This method can be called or applied to objects resembling arrays. The push method relies on a length property to determine where to start inserting the given values. If the length property cannot be converted into a number, the index used is 0. This includes the possibility of length being nonexistent, in which case length will also be created

თუ კოდის ეს ნაწილი მაინც გაუგებარია თქვენთვის გირჩევთ გადაიკითხოთ ფუნქციის call და apply მეთოდების შესახებ ჩემს მიერ რამდენიმე წლის წინ დაწერილი პოსტი.

იმედია ამ მომენტამდე ყველაფერი გასაგებია დროა გადავიდეთ შემდეგ ეტაპზე და ჩვენი myClass ბიბლიოთეკა აღვჭურვოთ რამდენიმე სასარგებლო მეთოდით. პირველი ეტაპისათვის საკმარისი იქნება შემდეგი რამდენიმე მეთოდის იმპლემენტაცია:

each – მეთოდი ნაპოვნი ელემენტების იტერაციისათვის, ქოლბექ ფუნქციის პარამეტრად გადაცემის შესაძლებლობით

1
2
3
4
5
6
7
8
9
10

myQuery.prototype = {

each: function(callback) {
for (var i = 0, el; (el = this[i++]);) {
callback.call(el, i);
}
return this;
}

};

1
2
3

$('div p').each(function(index) {
this.innerHTML = "This is " + index + "th paragraph
";
});

each ფუნქციის რეალიზაცია ძალიან მარტივია, “$” შესრულების შემდეგ “myQuery” ობიექტი უკვე შეიცავს ყველა ნაპოვნ DOM ელემენტს. გამომდინარე აქედან ელემენტებს შეგვილია მივმართოთ ინდექსით მაგ. “this[0]“, ხოლო რადგან myQuery ობიექტს გააჩნია length თვისება მისი იტერაცია და სათითაო ელემენტის ამოღება შესაძლებელია ჩვეულებრივი ციკლის ოპერატორით. ციკლის შიგნით უბრალოდ ხდება each მეთოდისათვის პარამეტრად გადაცემული ქოლბექ ფუნქციის გამოძახება call მეთოდის მეშვეობით მსგავსი გამოძახება გარანტიას გვაძლევს რომ ქოლბექ ფუნქცია შესრულებული იქნება პირველ პარამეტრად(კონტექსტი) გადაცემული DOM ელემენტის კონტექსტში. ხოლო ქოლბექფუნქციის შიგნით მიმდინარე DOM ელემენტს პირდაპირ შეგვიძლია მივმართოთ this – ის მეშვეობით.

ასევე each ფუნქციის რეალიზაცია განსაკუთრებულ ყურადღებას იმსახურებს ფუნქციის ბოლო სტრიქონი:

1	return this;

რეალურად myQuery ობიექტის each მეთოდი აბრუნებას ისევ myQuery ობიექტს ხოლო ეს ნიშნავს რომ ე.წ. Chaining უკვე უზრუნველყოფილია და წინა მაგალითის მოდიფიცირებით უკვე შეგვიძლია დავწეროთ შემდეგი კოდი:

1
2
3
4
5

$('div p').each(function(index) {
this.innerHTML = "This is " + index + "th paragraph
";
}).each(function(index) {
this.id = 'paragraph' + index;
});

ყურადღება მიაქციეთ each – ის ჯაჭვისებურად გამოძახებას.

კოდის დასრულებული ვერსია:

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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

Code.ge redesign… And I’m back B-)

იოსები — Tue, 08 Sep 2009 19:46:40 +0000

მოკლედ მოგესალმებით ყველას! ძალიან დიდი ხანია მინდოდა ამ პოსტის დაწერა თუმცა გარკვეულ მიზეზთა გამო შინაგანმა წინააღმდეგობის გრძნობამ ეს სურვილი ჩაკლა.

ჯერ კიდევ ორიოდე კვირის წინ ბლოგის დახურვასა და მის გაუქმებას ვაპირებდი, თუმცა ეს უაზრო სურვილი დავძლიე და შევეცდები განახლებული ენერგიით განვაგრძო წერა! ამისათვის განსაკუთრებული მადლობა მინდა გადავუხადო რამდენიმე ადამიანს(არ ჩამოვთვლი მათ სახელებს თვითონ მიხვდებით ვისაც გგულისხმობთ). ასევე დიდი მადლობა მინდა გადავუხადო იმ ადამიანებს რომლებიც ამ ბლოგით ჯერ კიდევ სარგებლობენ და აქ თავმოყრილი ინფორმაციითა და ჩემი პატარა ნამუშევრებით სარგებლობენ. ასევე დიდი ბოდიში მინდა მოვუხადო ყველა ჩემი მხირდან უპასუხოდ დატოვებული კომენტარის ავტორს.

პირველი ეტაპისთვის გამოვნახე დრო და გავაკეთე ბლოგის გარეგანი იერსახის სრული ცვლილება რომელიც ალბათ უკვე თვალში მოგხვდათ

გარდა ამისა მომზადებული მაქვს მთელი რიგი განახლებები ქართული კლავიატურის სკრიპტისთვის და სხვა თაროზე შემოდებული პროექტებისთვის რომლებსაც მალე გამოვფენ.

პირველ რიგში დღეს გავაოფენსორსე(როგორი ქართულია? ) LinGO ინგლისურ ქართული ლექსიკონი iPhone – სთვის რომელიც ხელმისაწვდომია GitHUB – ზე. ეს მინი პროექტი აუცილებლად მიიღებს დასრულებულ სახეს რადგან დღეიდან მასში მონაწილეობას მიიღებს ორი გამოცდილი Mac (და არა მარტო) დეველოპერი – ლაშა დოლიძე და ირაკლი ნადარეიშვილი! დიდი მადლობა ორივეს მხარდაჭერისა და ამ პროექტში მონაწილეობის სურვილისათვის.

სხვა სიახლეებსა და შეძლებისდაგვარად სასარგებლო ნამუშევრების შესახებ სულ მალე შეიტყობთ ამ ბლოგის მეშვეობით.

მაშ ასე I’m Back B-)

ქართული ტერმინოლოგია – დილემა

იოსები — Mon, 08 Jun 2009 06:56:21 +0000

მინდა გაგიზიაროთ ჩემი გულისტკივიული ინფორმაციული ტექნოლოგიების სფეროში არსებული ქართული ტექნიკური ტერმინოლოგიის შესახებ რომელმაც ბოლო კვირების მანძილზე არცთუ ცოტა დრო წამართვა და შეიძლება ითქვას ჩემი მცდელობები მთელი რიგი ტერმინებისა თუ ფრაზების ქართულად თარგმნასთან დაკავშირებით სრული კრახით დასრულდა.

პრობლემა თავისთავად რთულია და ერთის მხრივ შესაძლებელია რომ ამ პრობლემას ჩემი მხრიდან ქართულის არასათანადო ცოდნაც ამძაფრებს… მაგრამ… ეგება ვინმემ მიმითითოს ავტორიტეტულ წყაროზე ან ჯგუფზე ვინც ამ ტერმინების თარგმნით არის დაკავებული? კი ვიცი რომ ითარგმნება მთელი რიგი პროგრამული პაკეტები არსებობს გაქართულების ჯგუფები და ა.შ. მაგრამ მოდით რეალურად შევხედოთ პრობლემას. ერთია როდესაც თარგმნი “checkbox” – ს და მას არქმევ თოლიას(ჩემთვის სრულიად წარმოუდგენელი თარგმანია და ალბათ შინაგანად ვერასოდეს დავძლევ ბარიერს და ვერ გამოვიყენებ ამ ტერმინს), მაგრამ, მეორეა როდესაც უნდა თარგმნო ამ სფეროში დამკვიდრებული ისეთი სიტყვები და ფრაზები რომლებსაც განსაკუთრებული მნიშნველობა აქვთ შეძენილი კონტექსტიდან გამომდინარე.

ქვემოთ ჩამოვწერ ჩემის აზრით პრობლემურ სიტყებსა და ფრაზებს და ძალიან მოხარული ვიქნები თუ მცირედიც მაინც დამეხმარებით მათ თარგმნაში.

ჩემს შემთხვევაში პირველი და ყველაზე მნიშნველოვანი ფრაზა რის თარგმნასაც რამდენიმე წელია ვცდილობ და ვერაფრით ვერ მოვახერხე არის Content Management System(CMS). CMS – ის თარგმნა რამდენჯერმე ვთხოვე ქართულის ჩემზე გაცილებით უკეთ მცოდნე პიროვნებებს… თუმცა რა შედეგი მივიღე? არაფერი! და რატომ? პირველ რიგში Content – ის თარგმანის სავარაუდო ვარიანტებია “შინაარსი, შიგთავსი, არსი და ა.შ.” როგორც არ უნდა ვუტრიალოთ ამ სიტყვის ასეთი თარგმანი აბსოლუტურად არაფერს არ გვაძლევს, და რატომ? იმიტომ რომ კონკრეტულად “Content Management System” – ის კონტექსტში ეს სიტყვა მოიცავს გაცილებით მეტს ვიდრე უბრალოდ შინაარსს, კერძოდ კი კონტენტი ეს არის კომპლექსური მონაცემის ტიპი რომელსაც გააჩნია აზრი(meaning) და კონტექსტი. პირობით მაგალითად რომ განვიხილოთ ამ ბლოგის პოსტები, აღმოვაჩენთ რომ თითეულ ბლოგ პოსტს გარდა თავად პოსტისა გააჩნია სხვადასხვა ატრიბუტები(სათაური, გამოქვეყნების დრო, კატეგორა/კატეგორიები(შეიძლება განვიხილოთ როგორც კონტექსტი), ავტორი და ა.შ. გამომდინარე აქედან ბლოგ პოსტი ზოგადად არის სპეციფიური კონტენტის ტიპი. ახლა ისმის კითხვა შესაძლებელია რომ ცალკეულ ბლოგ პოსტს ვუწოდოთ მარტივად შინაარსი ან შიგთავსი? არ ვიცი მე პირადად ვერანაირ ასოცირებას ვერ ვახერხებ კონტენტთან… თუ ვცდები შემისწორედ ამით ძალიან გამახარებთ…

და რა მოხდება თუ წერისას ან საუბრისას უბრალოდ გამოვიყენებთ ფრაზას “კონტენტის მენეჯმენტის სისტემა”? რა დაშავდება ამითი? ხომ არ ჯობია თარგმნის ნაცვლად თამამად გამოვიყენოთ ასეთი პრობლემური სიტყვები/ფრაზები რომლებმაც ინდუსტრიაში გარკვეული გავრცელება ჰპოვა და სპეციფიური დატვირთავა შეიძინა? თუ ამ საკითხთან დაკავშირებით გაგიჩნდებათ პროტესტის გრძნობა, აბა მითხარით როგორ გადათარგმნით “Enterprise Java Beans(EJB)”? არა მითხრას ვინმემ? ვთარგმნოთ პირდაპირ? და იცით რას მივიღებთ?

Enterprise Java Beans(EJB) – საწარმოო ყავის მარცვლები აი ვინმემ მითხრას ახლა რა შუაშია საწარმოო ყავის მარცვლები?

თუ წინა ორი მაგალითი არ არის საკმარისი აბა სცადეთ თარგმნოთ “widget“, ძალიან მაინტერესებს როგორ უნდა ითარგმნოს ეს სიტყვა რომელიც ვების კონტექსტში შეიძლება განვმარტოთ როგორც – Interactive mini application that delivers content and functionality to the user. თუმცა კონტექსტიდან გამომდინარე ვიჯეტს სხვა განმარტებებიც გააჩნია…

მოკლედ ეს არის ის მცირედი რაც დღეს შემიძლია ვთქვა, თუმცა შეძლებისდაგვარად შევეცდები უფრო მეტი დავწერო ამ საკითხის ირგვლივ. იმედი მაქვს ამ ტკივილს გარკვეული რჩევებით გამიქარწყლებთ

Jetpak – დამატებების ახალი სისტემა Mozilla – სგან

იოსები — Thu, 21 May 2009 11:27:59 +0000

საერთოდ ცნობილია რომ კონკურენცია ძალიან კარგი რამ არის. ამ მტკიცებულების სისწორის კიდევ ერთი ძალიან კარგი მაგალითი გვაქვს სახეზე კერძოდ კი Google Chrome – სა და Mofilla Firefox – ის ე.წ. extension – ების სისტემების სახით.

მოგეხსენებათ რომ Google Chrome ძალიან ახალი ბრაუზერია რომელიც გასული წლის სექტემბრის დასაწყისში მოევლინა სამყაროს. მიუხედავად მისი ინოვაციურობისა მისი კრიტიკის ერთერთ მთავარ მიზეზად იქცა FF – ის მსგავსი დამატებების სისტემის არ ქონის გამო.

ცხადია ასე პირველივე დღიდან ყველაფერის ჩადებას ვერ მოახერხებდა Google თავის ახალ ბრაუზერში, თუმცა, როგორც მალე გაირკვა შეჩერებასაც არ აპირებდა. სულ რამდენიმე თვეში გამოჩნდა პირველი პროპოზალი რომელიც Chrome – ს დამატებების პლატფორმას შეეხებოდა. თუმცა ამ პროპოზალში ერთმა მეტად საგულისხმო დეტალმა გაიჟღერა – განსხვავებით FF – ის ანალოგიური სისტემისგან Chrome – ს დამატებების შესაქმნელად საკმარისია მხოლოდ HTML/CSS და JavaScript. არავითარი XUL, არავითარი რთული XML კონფიგურაციის ფაილები დამატების ინსტალაციისათვის და ა.შ.

Google – ს ეს გდაწყვეტილება ჩემთვის პირადად გაცილებით მისაღები იყო რადგან XUL – ის ვერანაირ აუცილებლობას ვერც FF – ში ვხედავდი მანამდე და სიმართლე ითქვას ვერც დღეს ვერ ვხედავ… თუმცა არც Mozilla – მ დააყოფნა და დღეს უკვე შემოგვთავაზა FF – ის დამატებების შექმნის ახალი მექანიზმი. კერძოდ კი Jetpak!

ციტატა პროექტის საიტიდან:

In short, Jetpack is an API for allowing you to write Firefox add-ons using the web technologies you already know.

რითია საინტერესო Jetpak? პირველ რიგში ისევე როგორც Crhome – ს შემთხვევაში, Jetpak – ის შემთხვევაშიც დამატების შესაქმნელად საკმარისია მხოლოდ HTML/CSS და JavaScript. ამ შემთხვევაშიც არავითარი XUL და რთული XML კონფიგურაციის ფაილები. ასევე არავიტარი ბრაუზერის გადატვირთვა დამატების ინსტალაციის შემდგომ და რაც ყველაზე ყველაზე ყველაზე მნიშვნელოვანია დეველოპმენტის პროცესში შეგვიძლია გამოვიყენოთ ნებისმიერი არსებული ინსტრუმენტული საშუალებები და Firebug დებაგირებისათვის რაც არსებულ მოდელში პრაქტიკულად შეუძლებელია. ასევე jQuery – ს მოყვარულთათვის ძალიან მნიშვნელოვანი ფაქტია რომ ეს ბიბლიოთეკა ნაგულისხმევად არის ჩადებული Jetpak – ში, რაც კიდევ უფრო გაამარტივებს დამატებების პროგრამირებას.

მართალია დასრულებამდე და საყოველთაო გავრცელებამდე კიდევ დიდი გზა აქვს გასავლელი Jetpak – ს, თუმცა მისი გამოყენება უკვე შესაძლებელია. ასე რომ თუ არ გეზარებათ შეგიძლიათ დააინსტალიროთ და დამატებების წერასაც შეუდგეთ

Handling “onchange” event revisited

იოსები — Sat, 16 May 2009 18:10:17 +0000

რამდენიმე თვის წინ დავწერე პოსტი, HTML ფორმის ელემენტის onchange ივენთისა და მისი დელეგირების შესახებ.

ნახსენებ პოსტში ნაჩვენებია onchange ივენთის დელეგირების მაგალითი სადაც ფორმის ყველა ელემენტის აღნიშნული ივენთის ცენტრალიზებული კონტროლი ხორციელდება მშობელი ელემენტის onchange ივენთის მეშვეობით.

მსგავსი შედეგის მიღწევა შესაძლებელი ე.წ. Event Bubbling – ის წყალობით რაც ივენთის, საწყისი ელემენტიდან მშობელი ელემენტისკენ გავრცელებას ეწოდება. მეტი თვალსაჩინოებისთვის იხ. სურათი(სურათისათვის განსაკუთრებული მადლობა ირაკლის):

ივენთის გავცელების(შვილიდან მშობლის მიმართულებით) ასეთი მეთოდი ყველა ბრაუზერში ერთნაირად მუშაობს. და წესით ეს უნდა ეხებოდეს ყველა ტიპის ივენთს. თუმცა როგორც მოსალოდნელი იყო IE – ში მისი მერვე ვერსიის ჩათვლით სწორედ ამ ივენთზე აღმოჩნდა შეზღუდვა და იგი საწყისი ელემენტს(ელემენტი რომელზეც უშუალოდ წარმოიშვა ეს ივენთი) იქეთ არ ვრცელდება.

ერთი შეხედვით, ამ ჩიხიდან რამდენიმე გამოსავალი შეიძლება მოიძებნოს:

ფორმის ყველა ელემენტის ჩამოვლა და მათთვის onchange ივენთ ჰენდლერის მინიჭება. თუმცა აქ მთელ რიგ პრობლემებს წავაწყდებით:
- ელემენტებზე ასეთი გზით ივენთ ჰენდლერების მინიჭება IE – ში იწვევს მეხსიერებასთან დაკავშირებულ პრობლემებს, ე.წ. memory leaks. ეს გარემოება განსაკუთრებით მნიშვნელოვანია თუ ფორმაში ბევრი ელემენტები გვაქვს.
- თუ ფორმის ელემენტები იტვირთება დინამიურად Ajax – ის მეშვეობით, ყოველი ასეთი ჩატვირთვის შემდეგ საჭიროა: ა) ყველა ფორმის ელემენტისა და მათი ივენთ ჰენდლერების განადგურება რათა თავიდან ავირიდოთ მეხსიერებასთან დაკავშირებული პრობლემები; ბ) ახლად ჩატვირთული ელემენტების იტერაცია და მათთვის შესაბამისი ივენთ ჰენდლერების განსაზღვრა.
დამეთანხმებით რომ აღწერილი ორი მეთოდი დიდი მოქნილებით არ გამოირჩევა.
ნაცვლად onchange ივენთისა გამოვიყენოთ onfocus და onblur ივენთები. თუმცა აღმოჩნდა რომ არც ამ ივენთების გავრცელება არ ხდება ტრადიციული(შვილიდან მშობლის მიმართულებით) მეთოდით.

გარკვეული კვლევა ძიების შემდეგ მივაგენი ისეთ ივენთებს(დიდი მადლობა PPK – ს) რომელთა ბაბლინგი IE – ში ისე მუშაობს როგორც საჭიროა. ეს ივენთებია onfocusin და onfocusout.

როგორ შეიძლება აღნიშნული ივენთების გამოყენება პრობლემის გადასაჭრელად? სანამ უშუალოდ კოდის წერას დავიწყებთ საჭიროა კარგად გავერკვეთ თუ როგორ მუშაობს onchange ივენთი HTML ფორმის ცალკეული ელემენტებისათვის და ასევე თუ რა გვერდის ავლის მექანიზმების გამოყენებაა შესაძლებელი IE – ში.

SELECT ელემენტი

ამ ელემენტის შემთხვევაში onchange ივენთი წარმოიშვება მხოლოდ იმ ჩამოსაშლელი სიიდან კონკრეტული ელემენტის ამორჩევის დროს. IE – ში იგივე ხდომილების ემულაციისათვის შესაძლებელია onclick ივენთის გამოყენება, თუმცა, ასეთ შემთხვევაში ივენთი ორჯერ წარმოიშვება ერთხელ ელემენტის გააქტიურებისას ხოლო მეორედ ჩამოსაშლელი სიიდან მნიშვნელობის არჩევისას. თუმცა ამ პრობლემის არიდება მარტივად არის შესაძლებელი სწორედ onfocusin და onfocusout ივენთების მეშვეობით რადგან ეს ორივე ივენთი წარმოიშვება onclick ივენთამდე, გამომდინარე აქედან შესაძლებელია წინა ივენთის ტიპის დამახსოვრება და შემდგომ უკვე დადგენა ეს იყო პირველი კლიკი თუ ჩამოსაშლელი მენიუდან ელემენტის არჩევა მოხდა?

INPUT text და TEXTAREA ელემენტები
ამ ელემენტების შემთხვევაში onchange ივენთი წარმოიშვება როდესაც ელემენტი კარგავს ფოკუსს. IE – ში იგივეს მიღწევა შესაძლებელია onfocusout ივენთის მეშვეობით.

INPUT checkbox და radio ელმენტები
ამ ელემენტების შემთხვევაში onchange ივენთი წარმოიშვება მათი მნიშვნელობის ცვლილების თანავე. IE – ში იგივე შედეგის მისაღებად მარტივად არის შესაძლებელი onclick ივენთის გამოყენება.

მაშ ასე წინა სამი პარაგრაფში გამოიკვეთა სამი ისეთი ივენთი რომელთა გამოყენებაც შესაძლებელია onchange ბაბლინგის ემულაციისათვის. ეს ივენთებია: onclick, onfocusin, onfocusout.

ამ ინფორმაციაზე დაყრდნობით მარტივად არის შესაძლებელი სულ რამდენიმე სტრიქონი კოდით გადავწყვიტოთ პრობლემა:

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
32
33
34
35
36
37
38
39
40
41

ეს არის და ეს კოდის დეტალური გარჩევით თავს აღარ შეგაწყენთ, ხოლო რეალური დემონსტრაცია შეგიძლიათ იხილოთ აქ.

JavaScript: Regex and Multi-line Mode

იოსები — Tue, 21 Apr 2009 09:43:27 +0000

დღეს აღმოვაჩინე რომ JavaScript – ის Regex იმპლემენტაციას გარდა სხვა ნაკლოვანებებისა ასევე არ გააჩნია ე.წ. “multi-line match mode”. ამ შემთხვევაში ლაპარაკი არ მაქვს რეგულარული გამოსახულების “m” მოდიფიკატორის მხარდაჭერაზე, ლაპარაკი მაქვს “s” მოდიფიკატორზე რომელიც “.“(წერტილი) სიმბოლოს აიძულებს გარდა სხვა სიმბოლოებისა(ნაგულისხმევად “.” ნიშნავს “ნებისმიერი სიმბოლო გარდა ახალი სტრიქონის სიმბოლოსი”) ასევე მოძებნოს ახალი სტრიქონის სიმბოლო.

ჩემი მარტივი ამოცანის გადასაჭრელად საჭირო იყო მოცემულ ტექსტში მეპოვა შემდეგი ტიპის მონაკვეთი:

1
2
3

function myFunction($param1, $param2) {
return array($param1, $param2);
}

ხოლო ნაპოვნი მონაკვეთიდან ამომეღო {code}{/code} ტაგებს შორის მოქცეული ტექსტი. თუმცა ეს გასაგები მიზეზების გამო არ გამომივიდა.

ნებისმიერ PCRE – სთან თავსებად იმპლემენტაციას გააჩნია “s” მოდიფიკატორი რომლის მეშვეობითაც მსგავსი ამოცანა წყდება ძალიან მარტივად. მაგალითად PHP – ში რეგულარულ გამოსახულებას ჩავწერდით შემდეგნაირად:

1
2
3

//ყურადღება მიაქციეთ გამოსახულების ბოლოში
//მიწერილ "s" სიმბოლოს
$regex = '/{code lang="(\w+)"}(.*?){\/code}/s'

სამწუხაროდ ასეთ გამოსახულებას JavaScript – ში ვერ დავწერთ. თუმცა, ცოტაოდენი კვლევაძიებისა და ექსპერიმენტების შემდგომ მივაგენი გამოსავალს რაც გამოიხატება სპეციფიური ე.წ. character class – ის გამოყენებაში. ამისათვის საჭიროა “\s” და “\S” მეტა სიმბოლოების დაჯგუფება character class – ში. შედეგად მივიღებთ შემდეგ გამოსახულებას:

[\s\S]

სადაც “\s” შეესაბამება ნებისმიერ უხილავ სიმბოლოს, ხოლო “\S” შეესაბამება ნებისმიერ არა უხილავ სიმბოლოს.

შედეგად მივიღე ასეთი JavaScript – ის რეგულარული გამოსახულება:

1	/{code\s+lang="(\w+)"}([\s\S]*){\/code}/

ეს გამოსახულება მუშაობს ანალოგიურად PCRE – სთან თავსებადი გამოსახულებისა რომელიც იყენებს “s” მოდიფიკატორს.

bmu.li

იოსები — Mon, 13 Apr 2009 09:15:02 +0000

ესე იგი, იშვიათად თუ მახარებს რაიმე ქართულ ვებში, თუმცა გუშინ ირაკლი შემომეხმიანა და თავისი ახალი პროექტის შესახებ შემატყობინა ეს არის სოციალური სერვისი სახელად ბმუ.ლი. რა საჭიროა ასეთი სერვისი? იხ. ციტირება სერვისის ვებ საიტიდან:

წარმოიდგინეთ, რომ Amazon.com-ზე იპოვეთ საინტერესო ფოტო-კამერა, და გნებავთ მეგობარს გაუგზავნოთ მასზე ლინკი SMS-ით. Amazon-ის მისამართები საკმაოდ გრძელია და დაახლოებით ასე გამოიყურება:

http://www.amazon.com/Canon-Digital-Camera-18-55mm-3-5-5-6/dp/B0012YA85A/ref=sr_1_1? ie=UTF8&s=photo&qid=1239587390&sr=1-1

ცხადია ამხელა მისამართს SMS-ში არავინ აკრეფს. ამიტომ, თქვენ შეგიძლიათ შეამოკლოთ ის bmu.li-ს საშუალებით, რის შედეგადაც მიიღებთ მოკლე მისამართს, მაგალითად: http://bmu.li/ss4 რომლის SMS-ით გაგზავნაც არანაირ პრობლემას აღარ წარმოადგენს.
bmu.li მხოლოდ SMS-ისთვის არ არის სასარგებლო. იგი შეგიძლიათ გამოიყენოთ ყველგან სადაც გრძელი მისამართების გაცვლა მოუხერხებელია: ფორუმებზე, ბლოგებზე, სოციალურ ქსელებში (ფეისბუკი, ოდნოკლასნიკი და სხვ.), ტვიტერში, იმეილში, გაზეთებში, რადიოს და სატელევიზიო რეკლამებში და გამოშვებებში ან თუნდაც მეგობრისთჳის ფურცლის ნაგლეჯზე მისამართის უცებ დასაწერად.

ყველაფერი ძალიან მარტივია. ამ სერვისის მეშვეობით შეგვიძლია წარმატებით დავამოკლოდ უსაშველოდ გრძელი და გაუგებარი URL – ები სულ რაღაც 10 სიმბოლომდე(http:// პრეფიქსის გამოკლებით) და გამოვიყენოთ უამრავ შემთხვევაში.

მოკლედ ძალიან, ძალიან სასარგებლო სერვისია რომელიც აუცილებლად გამოგადგებათ და იმედია სათანადოდ დავაფასებთ სულ ცოტა ხანში

ასევე მინდა ცოტათი გავთქვა ინსაიდერული ინფორმაცია და გითხრათ, რომ, სულ ცოტა ხანში კიდევ რამდენიმე საინტერესო სირპრიზი დაემატება სერვისს რაც კიდევ უფრო კომფორტულს გახდის მის მოხმარებას.

ასე რომ Hold on B-)

HTML Form “elements” Property

იოსები — Sun, 05 Apr 2009 23:16:04 +0000

ამ პოსტის დაწერამდე რამდენიმე წუთით ადრე წავაწყდი HTML form ელემენტის elements თვისებასთან დაკავშირებულ ერთ პრობლემას(შეცდომას) რომლის შესახებაც აქამდე არაფერი მსმენია და ცოტა არ იყოს უაზროდ დამახარჯინა დრო.

ცნობილია, რომ form ელემენტის აღნიშნული თვისება არის HTMLCollection ტიპის კოლექცია და იგი შეიცავს კონკრეტული HTML ფორმის შიგნით გამოყენებულ ყველა(input, select, button) ელემენტს. სწორედ ეს კოლექცია წარმოადგენს საჭირო ფორმის ელემენტებთან წვდომის ყველაზე უსაფრთხო(თურმე პირობითად) გზას.

როგორც აღმოჩნდა თუ ფორმის ელემენტებს მოვათავსებთ fieldset ტეგში(და წესით ეს ასეც უნდა გავაკეთოთ) elements კოლექცია მოულოდნელ რეზულტატს დაგვიბრუნებს. კერძოდ კი fieldset ელემენტიც(ან ელემენტები) ამ კოლექციაში აღმოჩნდება.

ჩემი ამოცანა მდგომარეობდა შემდეგში, რომ ფორმის ყველა ელემენტებისაგან მიმეღო მათი სახელებისა და მნიშნვნელობების ე.წ. key/value ობიექტი:

1
2
3
4
5

var map = {}, els = target.form.elements;
for (var i = 0, el; (el = els[i++]);) {
map[el.name] = el.value;
}
console.log(map);

თუმცა ძალიან უცნაური შედეგი მივიღე რადგან fieldset ელემენტს არც name და არც value თვისებები არ გააჩნია.

პრობლემის იდენტიფიცირების შემდგომ ინტერნეტში მოვიძიე მცირეოდენი ინფორმაცია:

The HTML 4 standard adds new
and tags to the set of elements that can appear within a form. In IE 5 and later, placing a
in a form causes a corresponding object to be added to the form’s elements[] array. Fieldset elements are not scriptable in interesting ways like other form elements are, and their objects do not have a type property like other form elements do. Therefore, the presence of Fieldset objects in the elements[] array seems like a mistaken design decision. This is particularly true since tags do not cause corresponding objects to be added to the elements[] array. The Mozilla and Netscape 6 browsers have chosen to follow Microsoft’s lead on this in order to be compatible with IE.

What this means is that if you define a form that contains fieldsets, the contents of the elements[] array differ in recent, HTML 4-capable browsers and in older, pre-HTML 4 browsers. In this situation, using position-based numeric indexes in the elements[] array is not portable, and you should define name attributes for all your form elements and refer to them by name.

მოკლედ კვლავ IE ნუ რას ვიზამთ რეალობა ასეთია

YouTube EDU და ბევრი საინტერესო მასალა პროგრამისტებისათვის

იოსები — Fri, 27 Mar 2009 17:28:07 +0000

დღეს YouTube – მ დასტარტა ახალი სევერისი YouTube EDU. ეს არის შესანიშნავი საგანმანათლებლო რესურსი რომელზეც უკვე შესაძლებელია არაერთი შესანიშნავი ლექციისა თუ ლექციების კურსის ნახვა.

ძალიან გამეხარდა და მომეწონა რომ აღნიშნულ რესურსზე წარმოდგენილია ისეთი მოწინავე ტექნოლოგიური უნივერსიტეტების სასწავლო მასალა როგორიც არის მაგ. MIT.

ძალიან დიდი დრო არ დამიხარჯავს, თუმცა მოვასწარი MIT – ის გვერდზე განთავსებული კურსის MIT 6.046J / 18.410J Introduction to Algorithms (SMA 5503) პირველი ლექციის მოსმენა და მინდა გითხრათ რომ უსაზღვროდ მომეწონა. საოცარი ლექტორია საოცარი გადმოცემის უნარითა და ლექციის წაყვანის მანერით.

გარდა მაგ კურსისა თუ დაძებნით სხვა უამრავ საინტერესო მასალასაც მიაგნებთ.

enjoy

საინტერესო ვაკანსია jobs.ge – ზე :D

იოსები — Sun, 22 Mar 2009 10:18:59 +0000

მიუხედავად იმისა რომ სამსახურს არ ვეძებ მაინც საკმაოდ ხშირად ვსტუმრობ jobs.ge – ს. ამას მარტივი მიზეზი აქვს, მაინტერესებს თუ რა ტიპისა და რანგის ვაკანსიებია ინფორმაციული ტექნოლოგიების სფეროში. თუმცა ზოგჯერ მართლა გასაოცარ მარგალიტს შეიძლება წააწყდე

მოკლედ ერთ ასეთ ვაკანსიას წავაწყდი დღეს:

IBS (Integrated Business Solutions) is a Georgian official business partner of 1C and business partner of 1C-bitrix, the software business firm offering automated business systems. IBS is pleased to announce a vacancy for for the full-time position of Web Programmer/Designer.

Responsibilities:

** Learn 1C-bitrix software solutions
** Prepare the sites in compliance with 1C-bitrix and according to the client demand
** Carry out all duties defined by the Manager on time.

Requirements:

** Relevant higher education (preferably in web design field)
** At least 6 months work experience as a Web Programmer/Designer
** Knowledge of the following program languages: HTML, GSS, JavaScript, PHP, Ajax, Asp.Net
** Excellent knowledge of Russian language (ability to analyze Russian texts and strong knowledge of spoken Russian)
** English language knowledge is desirable
** Strong sense of responsibility, organized person
** Programming skills
** Ability to work in a team
** Time management skills.

მისამართი: http://www.jobs.ge/17376/

რითი მიიქცია ამ ვაკანსიამ ყურადღება? ჩამოთვლილი პუნქტებიდან ორმა ფრიად მომხიბლა:

** Relevant higher education (preferably in web design field)

ისა რომელ უმაღლესში ასწავლიან ამას? შეიძლება ასწავლიან და არ ვიცი თუ მეტყვით კარგი იქნება

** Knowledge of the following program languages: HTML, GSS, JavaScript, PHP, Ajax, Asp.Net

ესე იგი Knowledge of the following program languages როგორ უნდა გავიგოთ? პროგრამის ენები? ეგება პროგრამირების ენები უნდა იყოს?

კიდევ საინტერესოა GSS რომელი “პროგრამის” ენაა?

ასევე საინტერესოა Ajax პროგრამისა თუ პროგრამირების ენაა? ან ენაა საერთოდ?

IE8 – ფინალური ვერსია გამოვიდა

იოსები — Thu, 19 Mar 2009 18:14:12 +0000

როგორც იქნა გვეღირსა და გამოვიდა IE8 – ს ფინალური ვერსია.

მიუხედავად იმისა რომ ბრაუზერების ვენდორებმა ძალიან გაგვანებივრეს ბოლო თვეების მანძილზე, ეს ინფორმაცია გაცილებით სასიხარულო და მნიშნველოვანი იყო ჩემთვის. რატომ? იმიტომ რომ დღესდღეობით IE6 და IE7 ორი გამორჩეულად ჩამორჩენილი ბრაუზერია რომლებსაც ბაზრის 67% უკავიათ ჯამში. იმედი მაქვს რომ IE8 რომელიც გაცილებით განვითარებულია მის ორ წინამორბედზე თუნდაც IE6 – ის სიკვდილს შეუწყობს ხელს. საბოლოო მომხმარებლისთვის შესაძლებელია ამას არსებითი მნიშნველობა არ აქვს, მაგრამ ჩემთვის(და არა მარტო) როგორც პროფესიონალისთვის ეს ძალიან ძალიან ძალიან მნიშვნელოვანია

მაშ ასე გადმოწერეთ და გაავრცელეთ რაც შეიძლება ჩქარა აიძულეთ ყველა IE – ს მომხმარებელს რომ ეს განახლება რაც შეიძლება სწრაფად გააკეთოს, ამითი ყველა დავაჩქარებთ IE6 – ის საბოლოო გარდაცვალების პროცესს

JavaScript: arrayChunk

იოსები — Fri, 20 Feb 2009 19:01:46 +0000

დღეს კოდის წერისას დამჭირდა მასივის რამდენიმე თანაბარ ნაწილად დაყოფა, PHP – ს ამ ამოცანის გადასაჭრელად გააჩნია შესაბამისი array_chunk() ფუნქცია, მაგრამ, JavaScript – ს მსგავსი არაფერი გააჩნია.

ეს არის ე.წ. quick solution ამ ამოცანის გადასაჭრელად:

1
2
3
4
5
6
7

function arrayChunk(array, size) {
var start = 0, result = [], chunk = [];
while((chunk = array.slice(start, start += size)).length) {
result.push(chunk);
}
return result;
}

ფუნქცია ღებულობს ორ პარამეტრს 1) მასივი რომელიც გვინდა დავყოთ; 2) თითოეული დანაყოფის ზომა;

თუ ამ ფუნქციას შეასრულებთ FireBug – ის კონსოლში:

var a = [1, 2, 3, 4, 5, 6, 7, 8, 9];
console.log(arrayChunk(a, 2));

მიიღებთ შემდეგ შედეგს:

 [[1, 2], [3, 4], [5, 6], [7, 8], [9]]

შედეგიდან გამომდინარე ფუნქციის საბოლოო რეზულტატი თვალსაჩინოა, იგი აბრუნებს სასურველი(ამ შემთხვევაში 2) ზომის მასივების მასივს.

დამატებითი დეტალების ახსნისგან თავს შევიკავებ რადგან ფუნქცია უმარტივესია, თუმცა ძალიან სასარგებლო

jCSS – რელიზის კანდიდატი

იოსები — Wed, 18 Feb 2009 10:19:27 +0000

დაუღალავი და საკმაოდ მძიმე შრომის შემდეგ დღეს ყველა ჩემს ხელთ არსებულ ვებ ბრაუზერში უნიტ ტესტებმა მწვანე აანთო რაც ნიშნავს იმას რომ jCSS – მა ყველა მითითებული ტესტი გაიარა წარმატებით(იხ. jCSS Test Suite).

ამ ეტაპისთვის ცოტას შევისვენებ და შემდეგ მოვუვლი კოდში არსებულ ინდუიზმს რომლისაც ცოტა არ იყოს და მრცხვენია. იმედი მაქვს რომ კვირის ბოლოს 1.0 ვერსიის რელიზს მოვასწრებ.

jCSS – CSS Selector Engine

იოსები — Thu, 12 Feb 2009 10:18:01 +0000

Hi all, ესე იგი მინდა წარმოგიდგინოთ ჩემი ერთერთი პატარა პროექტი სახელად jCSS. იგი წარმოადგენს JavaScript – ზე დაწერილ ე.წ. CSS Selector Engine – ს რომლის მეშვეობითაც მარტივად შეძლებთ HTML დოკუმენტის DOM ელემენტების ძებნას და რეზულტატის მიღებას ტიპიური CSS სელექტორების გამოყენებით.

მინდა აღვნიშნო რომ არავისთვის კონკურენციის გაწევას არ ვაპირებ ანუ jQuery, Mootools, Seezle და ა.შ. ეს არის ჩემი პირადი ექსპერიმენტი რომელსაც გარდა პრაქტიკული დანიშნულებისა გააჩნია წმინდა შემეცნებითი დატვირთვა და ამ მინი პროექტზე მუშაობისას ჩემს ძირითად ამოცანას წარმოადგენდა DOM ელემენტებში ნავიგაციისა და ციკლების წარმადობის კვლევა. ნებისმიერ შემთხვევაში სკრიპტი სრულად ფუნქციონალურია და შეგიძლიათ გამოიყენოთ.

წარმადობისა და რეალიზებული CSS სელექტორების ტესტი შეგიძლიათ ნახოთ აქვე. ტესტირებისათვის ვიყენებ Mootools – ის ავტორის მიერ შექმნილ ტესტირების სისტემას სახელად SlickSpeed ასე რომ შედეგებში ტენდენციურობა გამორიცხული შედარებისათვის გარდა jCSS – ისა ტესტში გამოვიყენე jQuery – ისა და Mootools – ის ბოლო სტაბილური ვერსიები.

გადაწერეთ jCSS!

გამოყენების მაგალითები:

1
2
3
4

var els = jCSS('#my-element-id div.my-class-name ul a');
for (var i = 0; i < els.length; i++) {
//do something wit elements
}

სულ ეს არის და ეს, ამ ეტაპზე მეტის დაწერას აზრი არ აქვს. თუ თქვენს მოსაზრებებსაც გამიზიარებთ ძალიან ძალიან გამახარებთ.

enjoy

Update:
განვაახლე jCSS აწი უფრო სწრაფია FF, Opera და IE – ში.

SlickSpeed Benchmark: http://www.code.ge/jcss-test/slickspeed/

დავამატე Unit Test Suite ბრაუზერებს შორის და სხვადასხვა ტიპის სელექტორების იმპლემენტაციის სისწორის კონტროლისათვის:
Unit Test Suite: http://www.code.ge/jcss-test/slickspeed/frameworks/test/

Update:

დაიფიქსა ყველა ძირითადი ბაგი;
დაიხვეწა და განვითარდა Query Parser;
დაემატა ყველა ე.წ. ფსევდო კლასების მხარდაჭერა გარდა nth-child და nth-last-child ფსევდო კლასებისა;
კომპლექსური ფსევდო კლასების მხარდაჭერა;
დავამატე DOM ელემენტების სორტირება ნეითივ სელექტორების მიერ დაბრუნებულ რეზულტატებთან თავსებადობის გამო. თუმცა ამან წარმადობა შედარებით დაწია IE – სა და Opera – ში.

დაიხვეწა კონტექსტური პარამეტრების მხარდაჭერა, გარდა DOM ელემენტისა კონტექსტურ პარამეტრად შესაძლებელია გამოვიყენოთ როგორც სელექტორი ასევე DOM ელემენტების მასივი. მაგ:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

var nodes = jCSS(
'div > p.paragraph-class-name',
document.getElementById('my-element-id')
);

var nodes = jCSS(
'div > p.paragraph-class-name',
'#my-element-id:visible'
);

var nodes = jCSS(
'a em',
document.getElementsByTagName('h1')
);

განვაახლე SlicckSpeed ანუ დავამატე YUI!, Prototype და Peppy სელექტორ ენჯინები;
SlickSpeed Benchmark: http://www.code.ge/jcss-test/slickspeed/
განვაახლე და გავამდიდრე UnitTest ფრეიმვორკი:
Unit Test Suite: http://www.code.ge/jcss-test/slickspeed/frameworks/test/

კომპლექსური სელექტორების იმპლემენტაცია საშუალებას იძლევა ელემენტები მოვძებნოთ დაახლოვებით მსგავსი სელექტორების გამოყენებით:

1
2
3
4
5

#form option:not(:contains('Nothing'),#option1b,:selected)

#form option:not(:not(:selected))[id^='option3']

:input:not(:image,:input,:submit)

ამ ეტაპზე ნეითივ სელექტორები გათიშული მაქვს Safari, Chrome, IE8 და FF3.1 – სთვის უკუთავსებადობის სრული ტესტირებისათვის. გარდა მაგისა არც ნეიტივ სელექტორები არ არის სრულყოფილად რეალიზებული და ნებისმიერ შემთხვევაში საჭიროა ე.წ. Custom Implmentation(განსაკუთრებით ეს ეხება IE8 – ს).

PHP: Array Tricks Part 1

იოსები — Sat, 07 Feb 2009 09:42:40 +0000

ამ პოსტს ჩემი ერთი მეგობრის თხოვნით ვწერ რომელთანაც გუშინ საუბარი მქონდა PHP – ს მასივებსა და for/foreach კონსტრუქციებთან მუშაობის შესახებ.

მასივები PHP – ს ერთერთი ყველაზე ძლიერი და განვითარებული მხარეა და შესაბამისად შეიცავს უამრავ ნიუანსს. ხშირ შემთხვევაში ასეთი ნიუანსები გამოუცდელი თუ გამოცდილი პროგრამისტების მიერ იგნორირებული რჩება და ამის შედეგად ვღებულობთ საკმაოდ დაუხვეწავ და სრულიად ზედმეტ კოდს.

ამ პოსტში მაქსიმალურად შევეცდები გადმოვცე ის დეტალები რაც PHP – სთან წლების მანძილზე მუშაობით შევიძინე და იმედი მაქვს რომ ეს ინფორმაცია თქვენთვისაც სასარგებლო იქნება. მაშ ასე შევუდგეთ საქმეს

ფუნქციიდან მასივის დაბრუნება

ხშირად მინახავს ასეთი ფუნქციები რომლებიც გარკვეული პირობის შესაბამისად აბრუნებენ ან მასივს ან null მნიშვნელობას(ასეთი შეცდომა მეც არაერთხელ მომსვლია და ამაში ტრაგიკული არაფერია). რეალურად ეს აბსოლუტურად ზედმეტი და არასაჭირო ქმედებაა რადგან შემდგომ დამატებითი კოდის წერის საჭიროებას იწვევს. ასეთ შემთხვევაში უმჯობესია ფუნქციამ დააბრუნოს უბრალოდ ცარიელი მასივი და არა null. მაგალითისათვის განვიხილოთ შემდეგი კოდი:

1
2
3

function getArray($flag) {
return $flag == true ? array(1, 2, 3) : null;
}

ეს ფუნქცია პარამეტრის მნიშვნელობიდან გამომდინარე დააბრუნებს ან მასივს ან null მნიშვნელობას. ახლა შევეცადოთ მისი გამოყენება:

1
2
3
4
5
6

//თუ ფუნქციამ დააბრუნებს მასივს გამოვბეჭდოთ მისი მნიშვნელობები
if ($array = getArray(true)) {
foreach($array as $key => $value) {
printf('key = %s and value = %s
', $key, $value);
}
}

ნჩვენებ კოდში ვიძახებთ getArray(true) ფუნქციას და ვანიჭებთ მას $array ცვლადს, რადგან ეს ხდება IF პირობის ოპერატორში მნიშვნელობის შემოწმებაც მომენტალურად ხდება და მისი არსებობის შემთხვევაში მასივის ელემენტები გამოიბეჭდება ეკრანზე.

დამეთანხმებით რომ ძალიან ჩვეულებრივი და ტიპიური შემთხვევაა. მაგრამ ისეთ შემთხვევაში თუ უბრალოდ მასივის ელემენტების გამობეჭდვა გვესაჭიროება და მეტი არაფერი ეს დაწერილი კოდი სავსებით ზედმეტია. ნაჩვენები მაგალითI შეგვიძლია გადავაკეთოთ შემდეგნაირად:

1
2
3
4
5
6
7
8
9

//ეს ფუნქცია ნებისმიერ შემთხვევაში აბრუნებს მასივს
function getArray($flag) {
return $flag == true ? array(1, 2, 3) : array();
}

$array = getArray(true);
foreach($array as $key => $value) {
printf('key = %s and value = %s
', $key, $value);
}

ამ კოდის შესრულების შემდეგ აბსოლუტურად იდენტურ შედეგს მივიღებთ, თუმცა ერთი ძალიან მნიშნველოვანი განსხვავებით, რომ, IF პირობის გამოყენება სრულიად აცილებულია თავიდან რადგან ფუნქცია ნებისმიერ შემთხვევაში აბრუნებს მასივს, ხოლო ასეთ შემოწმებას თავად foreach ახდენს ავტომატურად.

ახლა ბუნებრივად უნდა დაიბადოს შეკითხვა თუ რა მოვიგეთ განსაკუთრებული? აქ კიდევ ერთ ნიუანსზე შევაჩერებ თქვენს ყურადღებას და getArray ფუნქციის გამოყენების რამდენიმე სასარგებლო დეტალს შევეხები. ამისათვის საჭიროა კოდში შევიტანოთ პატარა ცვლილება:

1
2
3
4
5
6
7
8
9
10
11

//ეს ფუნქცია ნებისმიერ შემთხვევაში აბრუნებს მასივს
function getArray($flag) {
//ფუნქციის გამოძახების ინდიკატორი
echo ('invoked
');
return $flag == true ? array(1, 2, 3) : array();
}

//getArray() ფუნქციის გამოძახება foreach კონსტრუქციაში
foreach(getArray(true) as $key => $value) {
printf('key = %s and value = %s
', $key, $value);
}

ამ კოდის შესრულების შემდეგ მივიღებთ ანალოგიურ შედეგს, თუმცა უნდა აღინიშნოს, რომ, ამჯერად getArray() ფუნქცია გამოიძახება პირდაპირ foreach() კონსტრუქციაში და არა მის გარეთ. ეს ძალიან მნიშნელოვანი დეტალია რადგან ბევრ პროგრამისტს რატომღაც შეცდომად მიაჩნია ფუნქციის ამგვარი გამოძახება. რატომ? რადგან ფუნქცია გამოიძახება foreach – ში მიიჩნევა რომ მისი გამოძახება მოხდება იმდენჯერ რამდენი იტერაციაც იქნება ციკლში. თუმცა ეს ბუნებრივია ასე არ არის რასაც ზემოთ ნაჩვენები მაგალითიც ამტკიცებს.

ამ მაგალითიდან გამომდინარე უნდა გაგიჩნდეთ კიდევ ერთი შეკითხვა: და თუ მაინც მინდა მივანიჭო ცვლადს ფუნქციის მიერ დაბრუნებული მნიშნველობა? არც ეს არისპრობლემა:

1
2
3
4

//getArray() ფუნქციის დაბრუნებული მნიშვნელობის მინიჭება
foreach($array = getArray(true) as $key => $value) {
printf('key = %s and value = %s
', $key, $value);
}

რატომღაც ცვლადზე ფუნქციის მიერ დაბრუნებული მნიშვნელობის ეს მეთოდიც ხშირად არის იგნორირებული, თუმცა ასეთი მინიჭება სრულებით დასაშვებია და ყოველგვარი პრობლემების გარეშე მუშაობს.

და ასევე ბონუსის სახით გეტყვით რომ თუ მაინც გვესაჭიროება IF პირობის შესრულება ისე როგორც ეს ნაჩვენები იყო პირველ მაგალითში არც ამაზეა არანაირი პრობლემა

პირველ მაგალითში ნაჩვენები პირობა, ანუ:

if ($array = getArray(false)) {
   //rest of code here
}

იმუშავებს ერთნაირად მიუხედავად იმისა ფუნქცია დააბრუნებს ცარიელ მასივსა თუ null მნიშვნელობას რადგან PHP fale, null, array() და 0 მნიშვნელობის ასეთი შემოწმების შემთხვევაში ყოველთვის დააბრუნებს false – ს.

JavaScript WTF Vol. 5 – magic of onchange event

იოსები — Sat, 31 Jan 2009 11:06:59 +0000

ხშირად იყენებთ HTML ფორმის ელემენტების ამ ივენთს? და რა შემთხვევაში? ალბათ უფრო SELECT ელემენტთან მუშაობისას ხომ? თქვენი არ ვიცი მაგრამ ჩემს პირად პრაქტიკაში განსაკუთრებული გამოყენება ამ ივენთს არ ჰქონია… თუმცა ორიოდე დღის წინ ყველაფერი შეიცვალა და ჩემთვის ერთი ფრიად საინტერესო აღმოჩენა გავაკეთე.

ასეთი რამ გინახავათ?


//some other markup

დამეთანხმებით რომ ერთი შეხედვით ამ ივენთის DIV ელემენტთან გამოყენება ცოტა არ იყოს უცნაურია ხომ? რა ცვლილება უნდა მოხდეს ისეთი DIV ელემენტში რომ მისი დამუშავება მოვახდინოთ ამგვარი გზით? ან დავუშვათ და მოხდა ასეთი ცვლილება მაგრამ რანაირად?

მინდა გაგახაროთ და გითხრათ, რომ, პასუხი მარტივია. DIV ელემენტში არანაირი ასეთი ცვლილება არ მოხდება, მაგრამ, თუ მის შიგნით გვაქვს რადმენიმე SELECT და INPUT ელემენტი რომელთა ცვლილების კონტროლი გვესაჭიროება ეს კოდი მომენტალურად იდეალურ გადაწყვეტად იქცევა!

კლასიკურად უფრო სწორად ძველი სკოლის მიდგომით ასეთი ამოცანის გადაჭრის დროს ყველა, SELECT და INPUT ელემენტის onchange ივენთს მივანიჭებდით ჰენდლერს. თუმცა თუ გავიხსენებთ ფაქტს რომ DOM დოკუმენტში ხდომილება ვრცელდება საწყისი ელემენტისგან(ელემენტი რომელზეც უშუალოდ მოხდა ესა თუ ის მოვლენა) ანუ ელემენტების იერარქიაში ქვევიდან ზევით, ჩემს მიერ ნაჩვენები კოდიც მომენტალურად პრაქტიკულ დანიშნულებას შეიძენს. ამ ინფორმაციაზე დაყრდნობით შესაძლებელია ასეთი კოდის დაწერა:

1
2
3
4
5
6
7
8
9
10

<div id="container">
<input type="text" name="f1" />
<br />
<input type="text" name="f2" />
<br />
<select name="s1">
<option value="v1">Value 1</option>
<option value="v2">Value 2</option>
</select>
</div>

ნაჩვენები კოდის შესაბამისი ამოცანა მდგომარეობს ყველა INPUT და SELECT ელემენტის onchange ივენთის დაჭერასა და შესაბამის დამუშავებაში. ნაცვლად იმისა რომ გამოვიყენოთ სათითაოდ ყველა ელემენტს onchange ივენთი, მარტივად შეგვიძლია გავაკეთოთ შემდეგი რამ:

1
2
3
4
5
6
7
8
9
10
11
12
13

document.getElementById('container').onchage = function(e) {

//მოვიპოვოთ Event ობიექტი
e = e || window.event;

//მოვიპოვოთ საწყისი ელემენტი რომელზეც უშუალოდ დაფიქსირდა ივენთი
var targetElement = e.target || e.srcElement;

//თუ ელემენტი არის SELECT ან INPUT ტიპის შევასრულოთ დანარჩენი სამუშაო
if (/^input|select$/i.test(target.nodeName)) {
//do something here
}
}

დამეთანხმებით რომ ძალიან მარტივია ყველა ელემენტის ცვლილების ამდაგვარი ცენტრალიზებული კონტროლი. ეს არის ზუსტად ე.წ. Event Delegation მოდელი რომელიც ძალიან პოპულარულია დღესდღეობით. რატომ არ ვიცი მაგრამ ჩემთვის onchange ივენთი იმდენად ცალსახად იყო ასოცირებული ფორმის SELECT ელემენტთან რომ მისი ამდაგვარი გზით გამოყენების შესახებ არასოდეს მიფიქრია, თუმცა საბოლოო შედეგმა ყოველგვარ მოლოდინს გადააჭარბა.

იმედია ეს პირადად ჩემთვის ჭკუის სასწავლებელი შემთხვევა თქვენთვისაც სასარგებლო იქნება.

enjoy

ქართული Tech(ნოლოგიური) ბლოგები

იოსები — Sat, 31 Jan 2009 08:04:32 +0000

თითქმის წელიწად ნახევარი გავიდა მას შემდეგ რაც ქართული ტექნოლოგიური ბლოგების სიმცირის შესახებ დავწერე. რა შეიცვალა მას შემდეგ? სამწუხაროდ მინდა ვაღიარო რომ განსაკუთრებული არაფერი არ შეცვლილა. ამ დროის მანძილზე გამოჩნდა რამდენიმე ასეთი ბლოგი მაგრამ მხოლოდ რამდენიმე

რა გვჭირს? რატომ ვართ ასეთი ჩაკეტილები და რატომ არ ვწერთ? მესმის, ძალიან კარგად მესმის დროის სიმცირის ფაქტორი, მაგრამ, როგორ ახერხებენ ამ სფეროში ცნობილი დასავლელი კოლეგები თავიანთი ძირითადი საქმეების, კონფერენციებისა და სხვა აქტივობის პარალელურად ბლოგერობას? რატომ ვერ ვღებულობთ ჩვენ ამ შესანიშნავ საშუალებას ისე როგორც ეს ხდება სხვაგან? არა, არ იფიქროთ რომ ვინმეს ჭკუას ვარიგებ და ა.შ. სპეციალურად ვწერ მრავლობით რიცხვში და ჩემს თავსაც მოვიაზრებ როდესაც ვწერ “ჩვენ”. მინდა გითხრათ რომ ძალიან დიდ სიამოვნებას მანიჭებს ბლოგზე თუნდაც იშვიათად წერა, მცირე მაგრამ შეძლებისდაგვარად სასარგებლო საქმის კეთება GeoKBD – ს სახით და ა.შ. მაგრამ არც ეს მგონია საკმარისი.

დაახლოვებით 2005 წლიდან გავხდი ბლოგების აქტიური მკითხველი, შედარებით მოგვიანებით მე თვითონ დავიწყე წერა და რა მივიღე ამ წლების მანძილზე? რამდენიმე ძალიან მნიშვნელოვანი რამ: 1) მივიღე უზარმაზარი ცოდნა ისეთი ადამიანებისგან რომლებსაც არ ეზარებათ საკუთარი გამოცდილების გაზიარება; 2) ვისწავლე უკეთ წერა(არასოდეს არ გამოვირჩევოდი კარგი წერით და ძალიან ბევრი ხარვეზი მაქვს ამ მხრივ დღესაც) და აზრის უკეთ გადმოცემა; 3) დავინახე რომ თუნდაც ის მცირედი რასაც ამ ბლოგის მეშვეობით ვაკეთებ თურმე სასარგებლოც კი ყოფილა სხვა ადამიანებისთვის.

რა ვქნათ ახლა? კიდევ ერთხელ გავაკეთო მოწოდება? მოგიწოდებთ! კატეგორიულად მოგიწოდებთ! ჩვენ თავად თუ არ გავაუმჯობესეთ და არ შევცვალეთ ატმოსფერო ამ სფეროში, თუ არ გავხდით უფრო გახსნილები და ვიქნებით ასეთი კარჩაკეტილები ყოველთვის 10 წლით უკან ვიქნებით რაც დამეთანხმებით რომ ძალიან არასასიამოვნოა

P.S.
რამდენიმე ბლოგი რომელიც ამ პერიოდის მანძილზე შეიქმნა:

Georgian Game developers unite!
ActionScript.GE
გოდეს ინტერნეტ დავთარი
Blog for web developers
LedTechDesign

მეტი ახალი ბლოგები არ ვიცი და თუ მომაწოდებთ დიდად დამავალებთ

PHP: Document Root for FTP Client?

იოსები — Sat, 17 Jan 2009 13:52:29 +0000

ვებ სერვერზე PHP – თი ფაილებთან მუშაობა არაერთ სიურპრიზს გვთავაზობს, რაც ზოგჯერ საინტერესოა ზოგჯერ კი მართლა მოსაბეზრებელი თუმცა არის ერთი საკითხი რაზეც ამჯერად შევაჩერებ თქვენს ყურადღებას.

სერვერზე ფაილებთან მუშაობა PHP – ს შესაბამისი ფუნქციებით(fopen, fwrite, touch და ა.შ) საკმაოზე უფრო მოუხერხებელია უსაფრთხოების დეტალების გამო. არავისთვის არ წარმოადგენს საიდუმლოს რომ ვებ სერვერზე განთავსებულ ფაილებს უნდა გააჩნდეთ შექმნის, ჩაწერის, წაკითხვისა და წაშლის შეზღუდვები.

ასეთ შემთხვევაში ფაილებთან მუშაობის ერთადერთ სწორ და ეფექტურ გზად რჩება PHP FTP მოდულის გამოყენება, ან soeket – ებზე დაყრდნობით შექმნილი შესაბამისი რეალიზაციის გამოყენება, რაც ფაქტიურად ერთი და იგივეა.

რატომ FTP? იმიტომ, რომ სწორედ FTP მომხმარებელს გააჩნია ფაილებთან წვდომის შესაბამისი პერმიშენები, განსხვავებით იმ მომხმარებლისგან რომელიც ტრადიცულად აქვს PHP – ს.

პრობლემა
რამდენადაც ყველასათვის ცონბილია ვებ აპლიკაცია მუშაობს ე.წ. DOCUMENT_ROOT – ის შიგნით. მაგ:

/home/code.ge/public_html

სწორედ ამ მისამართის ქვეშ არის განლაგებული ვებ აპლიკაციის ყველა ფაილი, თუმცა იგივეს ვერ ვიტყვით სერვერთან FTP კლიენტით დაკავშირების შემთხვევაში. როდესაც სერვერს ვუკავშირდებით FTP კლიენტით მისამართი განსხვავდება და ხელთ გვაქვს მსგავსი ტიპის მისამართი:

ასეთ შემთხვევაში ერთსა და იმავე ფაილთან აღნისნული მეთოდებით მუშაობისას მივიღებთ ორ განსხვავებულ მისამართს:

//ტრადიციული შემთხვევა
/home/code.ge/public_html/dir/some-file.gif
//FTP - ს კლიენტის გამოყენების შემთხვევაში
/public_html/dir/some-file.gif

განსხვავება თვალსაჩიანოა?

ცხადია ფაილებთან მუშაობისას საჭიროა რაიმე კონსისტენტური გზის გამონახვა რომელიც ერთნაირად ეფექტურად იმუშავებს როგორც ზემოთხსენებული ჩვეულებრივი ფაილებთან სამუშაო ფუნქციების გამოყენებით, ასევე PHP – ს FTP გაფართოვების ფუნქციების გამოყენების მეშვეობით.

მარტივ შემთხვევაში ამ პრობლემის გადასაჭრელად უბრალოდ საკმარისია მსგავსი PHP კოდის დაწერა:

1
2
3
4
5
6

$ftp_mode = true;
if ($ftp_mode) {
define('_DOC_ROOT', '/public_html');
} else {
define('_DOC_ROOT', $_SERVER['DOCUMENT_ROOT']);
}

ამ შემთხვევაში ფაილებთან მუშაობისას გაუგებრობების თავიდან ასარიდებლად ყოველი ფაილის მისამართის წინ უბრალოდ შეგვიძლია “_DOC_ROOT” კონსტანტის გამოყენება, მაგ:

1
2
3
4

//FTP მოდულის გამოყენებით
ftp_mkdir($conn, _DOC_ROOT . '/foldername');
//ან უბრალოდ
mkdir(_DOC_ROOT . '/foldername');

მაგრამ დამეთანხმებით ეს მიდგომა ყოველად მიუღებელია ისეთ შემთხვევაში როდესაც პროგრამა სხვადასხვა სერვერებზე გამოიყენება და ყოველ ჯერზე კონფიგურაციის ხელით კეთება ნამდვილად არასასიამოვნოა

გამოსავალი
სიზარმაციდან და პრაქტიკული მოსაზრებებიდან გამომდინარე საჭიროა პატარა კოდის დაწერა რომელიც ამ პრობლემას მოგვიგვარებს და ავტომატურად გამოთვლის მისამართებს ორივე შემთხვევისათვის:

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
32
33
34
35
36
37
38
39
40
41
42
43
44

//მიმდინარე დირექტორია FTP კლიენტისათვის
$pwd = ftp_pwd($conn);

//ვინდოუსის შემთხვევაში დავიზღვიოთ თავი და შევცვალოთ მარცხენა სლეში მარჯვენათი
$pwd = str_replace('\', '/', $pwd);

//თუ მიმდინარე დირექტორია არ არის უბრალოდ "/", მოვაშალოთ თავსა და ბოლოში სლეშები
if ($pwd !== '/') {
$pwd = trim($pwd, '\/');
}

//აპლიკაციის ინსტალაციის დირექტორია, იგულისხმება რომ იგი ავტომატურად გამოთვლილია სკრიპტის მიერ
define('_APP_PATH', '/my-app-path');

//დავამუშავოთ ვებ სერვერის DOCUMENT_ROOT და მივამატოთ მას აპლიკაციის ინსტალაციის დირექტორია
$docroot = preg_replace(
array('~\\\~', '~^[a-z]:~i', '~^/|/$~'),
array('/', '', ''),
$_SERVER['DOCUMENT_ROOT']
) . _APP_PATH;

//დამხმარე ფუნქცია დროებითი მისამართის გენერაციისათვის
function path($pwd, $path) {
$tokens = array();
if ($pwd = trim($pwd, '\/')) {
$tokens[] = $pwd;
}
$tokens[] = $path;
return '/' . implode('/', $tokens);
}

//DOCUMENT_ROOT დავყოთ ნაწილებად
$tokens = explode('/', $docroot);
$apppath = null;

//შევასრულოთ ftp_chdir ფუნქცია იქამდე სანამ იგი არ დაგვიბრუნებს "true" - ს
while(ftp_chdir($conn, $apppath = path($pwd, implode('/', $tokens))) !== true) {
//DOCUMENT_ROOT მასივიდან ყოველ იტერაციაზე ამოვაგდოთ მასივის დასაწყისში მყოფი ელემენტი
array_shift($tokens);
$apppath = null;
}

//გამოვბეჭდოთ გამოთვლილი დირექტორია
echo $apppath;

სულ ეს არის

გილოცავთ ახალ წელს! :)

იოსები — Thu, 01 Jan 2009 12:09:35 +0000

ყველას გილოცავთ ახალ 2009 წელს! გისურვებთ ბედნიერებას, სიხარულს და წარმატებას ნებისმიერ ასპარეზზე!

ვისურვებდი რომ 2009 წელი ყოფილიყოს 2008 – ზე გაცილებით უკეთესი. ჩემთვის პირადად გასული წელი ძალიან ცუდიც იყო და ძალიან კარგიც, არც კი ვიცი რომელი ჭარბობს მაგრამ ვისურვებდი რომ ის ცუდი რაც 2008 წელს ვიხილე აღარასოდეს აღარ მეხილა და იგივეს ვუსურვებ ყველას ვინც კი ამ ბლოგს კითხულობს/წაიკითხავს/არ წაკითხავს და ა.შ. მოკლედ ყველას ყველას ყველას

აბა კიდევ ერთხელ ყველას გილოცავთ ახალ წელს

Ant, Rhino, YUICompressor & JS Packer

იოსები — Mon, 22 Dec 2008 07:06:33 +0000

დაახლოვებით ერთი წლის წინ ზედაპირულად შევეხე JavaScript ფაილების კომპრესიას. ძველი პოსტის მიხედვით თუ ვიმსჯელებთ არცთუ ისე ცუდი შედეგია. თუმცა რამდენიმე დეტალი მაინც საჭიროებს გადახედვას, კერძოდ კი:

JavaScript ფაილების კომპრესიის პროცესი არ არის ავტომატიზებული;
ფაილების კომპრესია მთლიანად ეყრდნობა დენ ედვარდსის ე.წ Packer – ს რომელიც გარკვეულ მიზეზთა გამო საკმაოდ მოუხერხებელია;

პირველ რიგში სანამ გადავალთ უშუალოდ ფაილების კომპრესიის ავტომატიზაციის პროცედურაზე საჭიროა საბოლოო ამოცანის სრულად ჩამოყალიბება.

მიზანი

JavaScript ფაილების გაერთიანება და ერთი საბოლოო ფაილის მიღება;
გაერთიანების შედეგად მიღებული ფაილის მინიფიკაცია და ობფუსკაცია;
მინიფიცირებული ფაილის ზომაში კიდევ უფრო მეტად შემცირება base62 კოდირებით;
საბოლოო ფაილის gzip კომპრესია;

პირველ რიგში მანამდე სანამ შევუდგებით JavaScript ფაილების კომპრესიის პროცესს მოვამზადოთ შესაბამისი გარემო, პირველ რიგში თქვენთვის მოსახერხებელ მისამართზე შექმენით კატალოგების შემდეგი სტრუქტურა:

project
    tools
    src
    build

ჩამოთვლილი პუნქტების რეალიზაციისათვის პოსტის სათაურში ნახსენები უტილიტებს გამოვიყენებთ.

უფრო კონკრეტულად კი მიზნის მისაღწევად დაგვჭირდება:

Apache Ant – თუ გიყენიათ JDK მას დამატებითი ინსტალაცია არ ესაჭიროება;
მოზილას Rhino – JavaScript for Java, JavaScript კოდის შესასრულებლად. გადმოწერეთ ბოლო ვერსია გახსენით არქივი და დააკოპირეთ js.jar ფაილი /project/tools კატალოგში;
ჟულიენ ლეკომტეს მიერ შექმნილი YUICompressor რომელსაც გამოვიყენებთ JavaScript ფაილების მინიფიკაციისა და ობფუსკაციისათვის. გადმოწერეთ ბოლო ვერსია გახსენით არქივი დააკოპირეთ build კატალოგში არსებული yuicompressor-2.x.x.ჯარ ფაილი /project/tools კატალოგში, შეუცვალეთ მას სახელი და დაარქვით yuicompressor.jar;
დენ ედვარდსის Packer რომლის მეშვეობითაც შევამცირებთ უკვე მინიფიცირებულ ფაილის მოცულობას
ჩემს მიერ დაწერილ პატარა სკრიპტი რომელიც საშულებას მოგვცემს Ant სკრიპტიდან გამოვიძახოთ Packer – ის pack მეთოდი მინიფიცირებული კოდის base62 კოდირებისათვის. ფაილი აერთიანებს როგორც ჩემს მიერ დაწერილ კოდს, ასევე დენ ედვარდსის Packer – ს. გადმოწერეთ ფაილი და დააკოპირეთ იგი /project/tools კატალოგში

სამუშაო გარემოს დასასრულებლად /project კატალოგში შექმენით ცარიელი build.xml ფაილი.
საბოლოო ჯამში მივიღებთ კატალოგებისა და ფაილების ასეთ სტრუქტურას:

project
    tools
        js.jar
        yuicompressor.jar
        pack.js
    src
    build
    build.xml

მანამდე სანამ შევუდგებით ფაილების უშუალო კომპრესიას /project/src კატალოგში დააკოპირეთ თქვენთვის სასურველი/საჭირო JavaScript ფაილები. ამ პოსტის წერისას, ტესტირებისათვის გამოვიყენე ორი ფაილი, jquery-1.2.6.js და jQuery – ს პლაგინი jquery.form.js .

დროა შევუდგეთ Ant სკრიპტის წერას რომლის მეშვეობითაც გავაერთიანებთ ფაილებს, გამოვიძახებთ შესაბამის უტილიტებს საჭირო პარამეტრებით და მივიღებთ საბოლოო შედეგს.

ნაჩვენები Ant სკრიპტის დეტალების განხილვა სცილდება ამ პოსტის მიზანს, თუმცა ყველა მნიშნველოვან დირექტივას თანდართული აქვს კომენტარები ზოგადი წარმოდგენის შესაქმნელად.

სკრიპტის შექმნის შემდეგ ტერმინალიდან შედით თქვენი პროექტის კატალოგში და აკრიფეთ შემდეგი ბრძანება:

ant

პროცესის დასრულების შემდეგ ტერმინალში დაინახავთ დაახლოვებით მსგავს შედეგს:

Buildfile: /Users/iosebdzmanashvili/Sites/test/pack/build.xml
init:
build:
     [java] completed...
BUILD SUCCESSFUL
Total time: 17 seconds

მაშ ასე ფაილების გაერთიანების, მინიფიკაციის, ობფუსკაციისა და კოდის base62 კოდირებაში გადაყვანის პროცესი დასრულებულია. თუ შეხვალთ /project/build კატალოგში, დაგხვდებათ სამი ფაილი:

library.js – რომელშიც გაერთიანებულია ზემოთ ნახსენები ორი JS ფაილი. ამ ფაილის ზომა დაახლოვებით 124KB – ს შეადგენს;
library.min.js – YUICompressor – ის მეშვეობით მინიფიცირებული ფაილი რომლის ზომაც დაახლოვებით 64KB – ა;
library.pack.js – Packer – ის მეშვეობით base62 კოდირებაში გადაყვანილი ფაილი რომლის ზომაც დაახლოვებით 36KB – ა;

დამერწმუნებით რომ შედეგი თვალსაჩიანოა და დამატებით კომენტარებს არ საჭიროებს, 124KB – დან საბოლოო ფაილი დავიყვანეთ 36KB – მდე რაც უდავოდ მნიშვნელოვანი სხვაობაა. თუ ამ ფაილს დამატებით პოსტის დასაწყიში ნახსენები მეთოდით დავამუშავებთ მისი ზომა დაახლოვებით 20KB – მდე დავა რაც თავისთავად ასევე მნიშვნელოვანია.

რეზიუმეს სახით ასევე მნიშვნელოვანია რამდენიმე დეტალი. თუ ფაილის მინიფიკაციის პროცესს შევასრულებდით მხოლოდ Packer – ის გამოყენებით, მივიღებდით დაახლოვებით იგივე შედეგს. თუმცა არსებობს ერთი საჩოთირო დეტალი რამაც YUICompressor – ის ჩართვისაკენ მიბიძგა.

როდესაც ვიყენებთ Packer – ს, მნიშნველოვანია გავითვალისწინოთ რომ ნებისმიერი ფუნქცია რომელსაც აღვწერთ სხვა ფუნქციისა ან მეთოდის შიგნით უნდა მთავრდებოდეს წერტილ მძიმით “;”. თუ ეს პირობა არ არის დაცული Packer – ის მიერ დაპატარავებული ფაილი უსარგებლო იქნება. ამ პროლემას აგვარებს YUICompressor, რადგან იგი ასეთ ფუნქციებს ავტომატურად ასრულებს წერტილ მძიმით ხოლო შედეგად ვღებულობთ სუფთა, Packer – ისათვის გამოსადეგ კოდს. მაგალითში ნაჩვენებია ასეთი შემთხვევა:

1
2
3
4
5

function myFunction() {
var myPrivateFunction = function() {
//rest of code here
} //აქ აუცილებელია წერტილ მძიმე
}

სამწუხაროდ Packer – ს არ აქვს იმის უნარი რომ ასეთი მცირე პრობლემები მოაგვაროს თავისით, თუმცა როგორც უკვე აღვნიშნე ამ პრობლემის თავიდან არიდება შესაძლებელია YUICompressor – ის მეშვეობით.

ასევე ყურადღებას შევაჩერებ ჩემს მიერ დაწერილ პატარა სკრიპტზე რომლის მეშვეობითაც ხდება მინიფიცირებული კოდის base62 კოდირებაში გადაყვანა. სკრიპტი არის Rhino – ს რამდენიმე სტრიქონი კლიენტი რომლის შესრულებაც შესაძლებელია ტერმინალიდან. მას ესაჭიროება ორი პარამეტრი: 1) საწყისი ფაილი რომლის კოდირებაც გვესაჭიროება; 2) საბოლოო ფაილის სახელი;

Rhino – ს კლიენტი კითხულობს პირველ პარამეტრად გადაცემული ფაილიდან JavaScript კოდს, იძახებს Packer – ის pack მეთოდს შესაბამისი პარამეტრებით, და მიღებულ შედეგს ინახავს შესაბამის ფაილში:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

output = java.io.FileWriter(arguments[1]); //obtain FileWriter object
output.write(
pack( //invoke Dean Edward's packer function
readFile( //read input file: http://www.mozilla.org/rhino/shell.html
arguments[0] //input file path
),
62, //base62 encode
0 //shrink variable names?
)
);
output.close();
print('completed...');

//Dean Edwrads' Packer code here

Mac Os X XAMPP: Tidy – ს ინსტალაცია PHP-5.2.6 – სთვის

იოსები — Thu, 18 Dec 2008 08:35:50 +0000

ამ პოსტში მინდა მოგითხროთ პატარა ისტორია Mac OS X – ზე PHP – ს რეკომპილაციით მიღებულ “სიამოვნებასა” და უსაზღვრო “კომფორტზე” რომელიც ბოლო ორი დღის განმავლობაში მივიღე.

მაშ ასე, თუ თქვენ იყენებთ XAMPP – ს და გესაჭიროებათ PHP – სთვის tidy გაფართოვების დამატება რომელიც სამწუხაროთ XAMPP – ს არ მოყვება, გაგახარებთ და გეტყვით რომ საკმაოდ სერიოზული პრობლემის წინაშე დგახართ

რა არის საჭირო ამ მიზნის მისაღწევად? მივყვეთ ნაბიჯ ნაბიჯ:

შეინახეთ ყველა არსებული პროექტი უსაფრთხო ადგილას;
გაანადგუროთ ყველა არსებული PHP ინსტალაცია, ამისათვის ტერმინალში აკრიფეთ შემდეგი ბრძანებები:
```
sudo rm -rf /Applications/xampp
sudo rm -rf /usr/include/php
sudo rm -rf /usr/lib/php
```
გადმოწეროთ XAMPP ის ბოლო ვერსია და დააინსტალირეთ;
გადმოწერეთ XAMPP – ის დეველოპერ პაკეტი ნებისმიერ ადგილას, შედით შესაბამის კატალოგში და დააინსტალირეთ შემდეგი ბრძანებით:
```
sudo tar xvfpz xampp-macosx-0.7.4-dev.tar.gz -C /Applications/xampp
```
გადმოწერეთ PHP 5.2.6 – ის დისტრიბუტივი და გახსენით არქივი ნებისმიერ მისამართზე, მაგ:
```
/Users/iosebdzmanashvili/Documents/PHP/php-5.2.6
```

გაუშვით XAMPP, შექმენით ნებისმიერი PHP ფაილი და გამობეჭდეთ phpinfo.

მიღებული რეზულტატიდან დააკოპირეთ და შეინახეთ კონფიგურაციის პარამეტრები, ეს ნაბიჯი აუცილებელია არსებული კონფიგურაციის შესანარჩუნებლად. ორიგინალი დაახლოვებით გამოიყურება ასე:

./configure --prefix=/Applications/xampp/xamppfiles --program-suffix=-5.2.6 --libdir=/Applications/xampp/xamppfiles/lib/php/php5 --includedir=/Applications/xampp/xamppfiles/include/php/php5 --with-apxs2=/Applications/xampp/xamppfiles/bin/apxs --with-config-file-path=/Applications/xampp/etc --with-mysql=/Applications/xampp/xamppfiles --disable-debug --enable-bcmath --enable-calendar --enable-ctype --enable-dbase --enable-discard-path --enable-exif --enable-filepro --enable-force-cgi-redirect --enable-ftp --enable-gd-imgstrttf --enable-gd-native-ttf --with-ttf --enable-magic-quotes --enable-memory-limit --enable-safe-mode --enable-shmop --enable-sigchild --enable-sysvsem --enable-sysvshm --enable-track-vars --enable-trans-sid --enable-wddx --enable-yp --with-ftp --with-ncurses=/Applications/xampp/xamppfiles --with-gdbm=/Applications/xampp/xamppfiles --with-jpeg-dir=/Applications/xampp/xamppfiles --with-png-dir=/Applications/xampp/xamppfiles --with-freetype-dir=/Applications/xampp/xamppfiles --without-xpm --with-zlib=yes --with-zlib-dir=/Applications/xampp/xamppfiles --with-openssl=/Applications/xampp/xamppfiles --with-expat-dir=/Applications/xampp/xamppfiles --enable-xslt=/Applications/xampp/xamppfiles --with-xsl=/Applications/xampp/xamppfiles --with-dom=/Applications/xampp/xamppfiles --with-ldap=/Applications/xampp/xamppfiles --with-gd=/Applications/xampp/xamppfiles --with-mysql-sock=/Applications/xampp/xamppfiles/var/mysql/mysql.sock --with-mcrypt=/Applications/xampp/xamppfiles --with-mhash=/Applications/xampp/xamppfiles --enable-sockets --with-curl=/Applications/xampp/xamppfiles --enable-mbregex --enable-zend-multibyte --with-zip=/Applications/xampp/xamppfiles --enable-exif --with-sqlite --with-libxml-dir=/Applications/xampp/xamppfiles --enable-soap --enable-pcntl --enable-dbx --with-mysqli=/Applications/xampp/xamppfiles/bin/mysql_config --with-bz2=/Applications/xampp/xamppfiles --with-ming=shared,/Applications/xampp/xamppfiles --with-pear=/Applications/xampp/xamppfiles/lib/php/pear --with-mssql=/Applications/xampp/xamppfiles --with-imap-dir=/Applications/xampp/xamppfiles --with-imap=/Applications/xampp/xamppfiles --enable-mbstring=all,/usr --with-gettext=/Applications/xampp/xamppfiles --with-pdo-mysql=/Applications/xampp/xamppfiles

ახლა იწყება ყველაზე საინტერესო და არასასიამოვნო პროცესი რომლის გარკვევაზეც არცთუ ცოტა დრო დამეხარჯა:

გახსენით ფაილი:
```
/Users/iosebdzmanashvili/Documents/PHP/php-5.2.6/ext/tidy/tidy.c
```
მოძებნეთ გახსნილ ფაილში #include “tidy.h” და გადაიტანეთ იგი ფაილის დასაწყისში.
tidy – ს xampp – ში დასაკოპირებლად ტერმინალში აკრიფეთ შემდეგი ბრძანება:
```
sudo ditto /usr/include/tidy /Applications/xampp/xamppfiles/include
```
ეს პროცედურა მნიშნველოვანია რადგან PHP – სთან არსებული კონფლიქტის გამო საჭიროა tidy – ს ფაილებში ცვლილების შეტანა, ხოლო XAMPP – ში tidy არ დევს.

ახლად დაკოპირებული კატალოგიდან გახსენით ფაილი:

/Applications/xampp/xamppfiles/include/tidy/platform.h

და 526 – ე ხაზიდან 531 ხაზის ჩათვლით არსებული კოდი:

#if !defined(HPUX_OS) && !defined(CYGWIN_OS) && !defined(MAC_OS_X) && !defined(BE_OS) && !defined(SOLARIS_OS) && !defined(BSD_BASED_OS) && !defined(OSF_OS) && !defined(IRIX_OS) && !defined(AIX_OS) && !defined(LINUX_OS)
typedef unsigned int uint;
#endif
#if defined(HPUX_OS) || defined(CYGWIN_OS) || defined(MAC_OS) || defined(BSD_BASED_OS) || defined(_WIN32)
typedef unsigned long ulong;
#endif

ჩაანაცვლეთ შემდეგი კოდით რათა თავიდან ავირიდოთ PHP – სთან არათავსებადობის პრობლემა:

#if !defined(HPUX_OS) && !defined(CYGWIN_OS) && !defined(MAC_OS_X) && !defined(BE_OS) && !defined(SOLARIS_OS) && !defined(BSD_BASED_OS) && !defined(OSF_OS) && !defined(IRIX_OS) && !defined(AIX_OS) && !defined(LINUX_OS)
#undef uint; /* avoid conflict with PHP */
typedef unsigned int uint;
#endif
#if defined(HPUX_OS) || defined(CYGWIN_OS) || defined(MAC_OS) || defined(BSD_BASED_OS) || defined(_WIN32)
#undef ulong; /* avoid conflict with PHP */
typedef unsigned long ulong;
#endif

შენახულ PHP – ს კონფიგურაციას დაამატეთ შემდეგი ორი პარამეტრი.

იმ შემთხვევაში iconv არ არის თქვენს კონფიგურაციაში, საჭიროა მისი ცხადად მითითება, წინააღმდეგ შემთხვევაში კომპილაცია წარუმატებელი იქნება:
```
--with-iconv=/Applications/xampp/xamppfiles
```
ასევე მიუთითეთ tidy – ს გასააქტიურებლად საჭირო პარამეტრი:
```
--with-tidy=/Applications/xampp/xamppfiles
```

კონფიგურაციის პარამეტრების მომზადების შემდეგ ტერმინალიდან გადადით PHP – ს დისტრიბუტივის კატალოგში:

cd /Users/iosebdzmanashvili/Documents/PHP/php-5.2.6

და ტერმინალში შეასრულეთ შემდეგი ბრძანება:

./configure --prefix=/Applications/xampp/xamppfiles --program-suffix=-5.2.6 --libdir=/Applications/xampp/xamppfiles/lib/php/php5 --includedir=/Applications/xampp/xamppfiles/include/php/php5 --with-apxs2=/Applications/xampp/xamppfiles/bin/apxs --with-config-file-path=/Applications/xampp/etc --with-mysql=/Applications/xampp/xamppfiles --disable-debug --enable-bcmath --enable-calendar --enable-ctype --enable-dbase --enable-discard-path --enable-exif --enable-filepro --enable-force-cgi-redirect --enable-ftp --enable-gd-imgstrttf --enable-gd-native-ttf --with-ttf --enable-magic-quotes --enable-memory-limit --enable-safe-mode --enable-shmop --enable-sigchild --enable-sysvsem --enable-sysvshm --enable-track-vars --enable-trans-sid --enable-wddx --enable-yp --with-ftp --with-ncurses=/Applications/xampp/xamppfiles --with-gdbm=/Applications/xampp/xamppfiles --with-jpeg-dir=/Applications/xampp/xamppfiles --with-png-dir=/Applications/xampp/xamppfiles --with-freetype-dir=/Applications/xampp/xamppfiles --without-xpm --with-zlib=yes --with-zlib-dir=/Applications/xampp/xamppfiles --with-openssl=/Applications/xampp/xamppfiles --with-expat-dir=/Applications/xampp/xamppfiles --enable-xslt=/Applications/xampp/xamppfiles --with-xsl=/Applications/xampp/xamppfiles --with-dom=/Applications/xampp/xamppfiles --with-ldap=/Applications/xampp/xamppfiles --with-gd=/Applications/xampp/xamppfiles --with-mysql-sock=/Applications/xampp/xamppfiles/var/mysql/mysql.sock --with-mcrypt=/Applications/xampp/xamppfiles --with-mhash=/Applications/xampp/xamppfiles --enable-sockets --with-curl=/Applications/xampp/xamppfiles --enable-mbregex --enable-zend-multibyte --with-zip=/Applications/xampp/xamppfiles --enable-exif --with-sqlite --with-libxml-dir=/Applications/xampp/xamppfiles --enable-soap --enable-pcntl --enable-dbx --with-mysqli=/Applications/xampp/xamppfiles/bin/mysql_config --with-bz2=/Applications/xampp/xamppfiles --with-ming=shared,/Applications/xampp/xamppfiles --with-pear=/Applications/xampp/xamppfiles/lib/php/pear --with-mssql=/Applications/xampp/xamppfiles --with-imap-dir=/Applications/xampp/xamppfiles --with-imap=/Applications/xampp/xamppfiles --enable-mbstring=all,/usr --with-gettext=/Applications/xampp/xamppfiles --with-pdo-mysql=/Applications/xampp/xamppfiles --with-iconv=/Applications/xampp/xamppfiles --with-tidy=/Applications/xampp/xamppfiles

./configure ოპერაციის დასრულების შემდეგ ტერმინალში აკრიფეთ შემდეგი სამი ბრძანება:

პროცესის დასრულების შემდეგ:

make clean //გაუგებრობების თავიდან ასაცილებლად
make //აქ შეგიძლიათ ყავა მოიმზადოთ, სიგარეტი მოწიოთ და კურიერს უყუროთ   
sudo make install

გილოცავთ! ინსტალაცია დასრულებულია გადატვირთეთ Apache და განაგრძეთ მუშაობა

P.S.
ფაილების მისამართებში გამოყენებული მომხმარებელის სახელი “iosebdzmanashvili” უნდა შეცვალოთ თქვენი მომხმარებლის სახელით

ქართველი პროგრამისტები მსოფლიო ჩემიპიონატის ფინალში!

იოსები — Tue, 02 Dec 2008 08:00:29 +0000

ტექნოლოგიების სფეროსა და საქართველოს შორის იმდენად სპეციფიური კავშირია რომ ძნელია რაიმემ გაგახაროს ან ინტერესი გაგიღვიძოს მაგრამ ახალგაზრდა თაობა აშკარად მუხლჩაუხრელად შრომობს და უკვე მნიშნველოვან წარმატებებსაც აღწევენ. მაშ ასე, ქართველი პროგრამისტები კერძოდ კი:

Tbilisi SU 1 (Bogdanov, Jimsheleishvili, Lekveishvili)

მსოფლიო ჩემპიონატის ფინალში არიან რომელიც 2009 წლის აპრილში ჩატარდება შვედეთის ქალაქ სტოკჰოლმში.

ვულოცავ გუნდის ყველა წევრს და მთელი გულით ვგულშემატკივრობ

Update:
დეტალები შეგიძლიათ იხილოთ გიორგი ლეკვეიშვილის ბლოგზე

Google Trip

იოსები — Sat, 25 Oct 2008 11:27:46 +0000

მოკლედ დღეს გამთენიისას დავბრუნდი კრაკოვიდან, სადაც გუგლს ვსტუმრობდი. სტუმრობის მიზეზი ზედმეტად საქმიანი და მოკლე ვადებში გაწერილი იყო ასე რომ ბევრი რამ რასაც ვგეგმავდი ვერ მოვასწარი.

ვინც არ იცის მათთვის: სექტემბრის დასაწყისში CV გავუგზავნე გუგლს რაზეც გამომეხმაურნენ, სატელეფონო ინტერვიუ დამინიშნეს და დაახლოვებით 10 დღეში დამიკავშირდნენ. სატელეფონო ინტერვიუ ძალიან საინტერესო იყო, დეივი, ინჟინერი ნიუ იუორკიდან ძალიან გახსნილი, მხიარული და ენაწყლიანი პიროვნება აღმოჩნდა დაახლოვებით 50 წუთიანი ტექნიკური ინტერვიუს შემდეგ მითხრა რომ მეც შემეძლო შეკითხვების დასმა. ჩემს შეკითხვებს ამომწურავად და ხალისით უპასუხა ბოლოს დავემშვიდობეთ ერთმანეთს და მითხრა, რომ, ამ ინტერვიუს შესახებ დაწერდა ანგარიშს და ერთი კვირის განმავლობაში პასუხს შემატყობინებდნენ… მეორე საღამოს დამირეკეს… უშუალოდ პოლონეთის, კრაკოვის ოფისიდან და გამესაუბრნენ. საბოლოო ჯამში შემომთავაზეს ე.წ. face to face ინტერვიუზე ჩასვლა გუგლის ოფიში. რა თქმა უნდა ხარჯები მთლიანად გუგლმა აიღო თავის თავზე.

მოკლედ აღარ დავწვრილმანდები მოსაწვევების, ბილეთების და ვიზის აღების გაწელილი პროცედურების აღწერით და პირდაპირ გადავალ საქმეზე

გუშინწინ ჩავედი ულამაზეს ქალაქ კრაკოვში სადაც მდებარეობს გუგლის ოფისი. დავბინავდი სასტუმროში რომელიც გუგლის ოფისიდან სულ რაღაც სამი წუთის სავალზე იყო ფეხით. დავისვენე და მოვემზადე მეორე დღისთვის. დილით ადრე ავდექი და გევეშურე გუგლის ოფისისკენ. მოკლედ როგორც იქნა შევაბიჯე მისტიური გუგლის ოფისში სადაც ძალიან გულღიად დამხვდნენ და მიმიღეს გარკვეული აუცილებელი პროცედურების გავლის შემდეგ მითხრეს რომ ნახევარი საათი უნდა მომეცადა და მეც განვთავსდი ერთერთ სავარძელში.

პირველი რაც მეცა თვალში ეს იყოს ფეხშიშველი თანამშრომლები მართლა, ყოველგვარი გადაჭარბების გარეშე… ზოგი ჩვეულებრივ სახლის ფლოსტებშიც დადიოდა(მოგვიანებით ერთერთი ინტერვიუერი ზუსტად მსგავს ფორმაში წარსდგა ჩემს წინაშე). ასევე სანამ ვიცდიდი ჩემმა კოორდინატორმა, ვიოლეტამ, ვიღაცას დაუძახა და გასართობ დარბაზში ერთი ხელი მაგიდის ჩოგბურთის თამაშიც მოასწრეს…

მოკლედ ზუსტად ნახევარ საათში დამიძახა აქოშინებულმა ვიოლეტამ და დაიწყო ექვს საათიანი მარათონი, რომელიც საღამომდე გაგრძელდებოდა რა შემიძლია გითხრათ ამ ინტერვიუებზე? პირველ რიგში ჩემდა გასაოცრად ყველა ინტერვიუ ძალიან რეალური იყო, არავითარი უცნაური ან სულელური შეკითხვები.. ყველა შეკითხვა აბსოლუტურად ჩამოყალიბებული და კონკრეტული იყო.

მაშ ასე, ინტერვიუ პირველი:

ინტერვიუერი 40 წლამდე პიროვნებამ(როგორც აღმოჩნდა უზარმაზარი გამოცდილებისა და ცოდნის მქონე) ღიმილით წარმიდგინა თავისი თავი და მთხოვა ჩემს შესახებ მომეყოლა რაიმე მეც მოვუყევი… შემდგომ გადავიდა საქმეზე და დამისვა ამოცანა და მთხოვა მეპოვა გამოსავალი და ამეღწერა ალგორითმი… მომიწია დაფასთან დგომა და ჩემი მოსაზრებების გადმოცემა საერთო ჯამში როგორც ჩანს კმაყოფილი დარჩა და თავადაც განავრცო თემა ჩემს მიერ ჩამოყალიბებული გადაწყვეტის საფუძველზე.

შემდეგ მაგიდაზე დადო ანდროიდი იგივე G1 და მკითხა თუ ვიცოდი მის შესახებ რაიმე? ცოტა რამ ვიცოდი და ვუთხარი ამის შესახებ… შემდეგ მკითხა iphone უფრო მომწონს თუ ანდროიდი? ვუთხარი ჩემი მოსაზრებები აიფონის სასარგებლოდ და ჩაეცინა და უეცრად აიფონის sdk – ზე დამისვა შეკითხვა(სივიში მეწერა ამის შესახებ და ლოგიკური შეკითხვა იყო). მაქსიმალურად ამომწურავად ვუპასუხე. როგოც შევატყვე ამ პასუხითაც კმაყოფილი დარჩა. შემდგომ სიტყვა ჩამომიგდო ვებ სერვისებზე და შედარებით ვრცლად მოგვიწია კამათმა ამ თემაზე… დაახლოვებით 20 წუთი. საბოლოო ჯამში პირველი ინტერვიუს დრო ამოიწურა, ხელი ჩამოვართვით ერთმანეთს და დავემშვიდობეთ

ინტერვიუ მეორე:

მეორე ინტერვიუზე ორი ინტერვიუერი მყავდა, დაახლოვებით ჩემი ასაკის ბიჭი და შედარებით ახალგაზრდა პუტკუნა გოგონა

ამ ინტერვიუზეც მომიწია ვებ სერვისებზე საუბარმა განსაკუთრებით აქცენტირებული იყო REST რასაც ყოველგვარი გადაჭარბების გარეშე ეფექტურად გავართვი თავი. ბრაუზერებს შორის არათავსებადობაზე გარკვეული მასტერ კლასი ჩავუტარე, რატომ მკითხეს ამის შესახებ არ ვიცი მაგრამ აშკარად დავადუმე… შემდგომ უეცრად თითქოს შური იძიაო მომიბრუნდა ერთერთი და რაღაცა დამიხატა დაფაზე და აბა გრაფების თეორიაო ნუ გამომდინარე იქედან რომ გრაფების თეორია არ ვიცი წავბორძიკდი თუმცა გარკვეული მსჯელობის შემდეგ ლოგიკური პასუხი მოვძებნე და მთლად უპასუხოდ არ დამიტოვებია შეკითხვა.

შემდეგ ვისაუბრეთ ვებ აპლიკაციებში გამოყენებად პატერნებზე, ფრონტ კონტროლერი, პეიჯ კონტროლერი და ა.შ ესეც საკმაოდ მარტივად გადავატარე. და ინტერვიუს დრო კვლავ ამოიწურა. დამემშვიდობნენ ღიმილით და დაიწყო შემდეგი ჩემის აზრით ყველაზე დინამიური და რთული ინეტერვიუ…

ინტერვიუ მესამე:

შემოვიდა დაახლოვებით 35 წლამდე მხიარული და ენაწყლიანი ინჟინერი. გაცნობისა და მოკლე შესავლის შემდეგ პირდაპირ გადავიდა საქმეზე. დამისვა კონკრეტული ამოცანა, და მკითხა როგორ გადავწყვეტდი? დაახლოვებით 5 წუთში დავასრულე ჩემს მიერ არჩეული აპლიკაციის დიზაინის ახსნა, შეაქო არჩევანი და ლოგიკურად გააგრძელა იგივე თემა სხვა დამატებით დეტალებზე ჩაძიებით. მინდა ვთქვა წარმატებით გავიარეთ ეს ნაწილიც.

შემდეგ გადავიდა კონკრეტულ ტექნოლოგიებზე, კერძოდ კი იჯეიბი2 – სა და ჰიბერნეიტს შორის შედარება გამაკეთებინა. მალევე მოვრჩით ამ თემას და უეცად გადავიდა ჯ2ეე – სა ჯედიბისის ლანძღვაზე. გაასწორა მიწასთან რეალციური მონაცემთა ბაზები და ა.შ. ამის მიზეზად მოიყვანა ამ ტექნოლოგიური კომპონენტების ცუდად მასშტაბირების უნარი. და შემდეგ მკითხა მე რას ვფიქრობდი იგივე თემაზე? შეძლებისდაგვარად ვუთხარი ჩემი პასუხი და ისიც მაქსიმალურად ჩამეძია მოკლედ ეს საკითხიც გავიარეთ და უცბად მომიჯდა გვერდზე ფურცელი და პასტა მომცა რასაც მოაყოლა განცხადება რომ უნდა დამეწერა კოდი ფურცელზე და მას უნდა ეყურებინა დამისვა რაღაც უსაძაგლესი ამოცნა მრავალნაკადური პროგრამირების შესახებ, სიმართლე ითქვას ამოცანა ვერც თავიდან გავიგე, ვერც შუაში და ვერც პოსტ ფაქტუმ როდესაც უბრალოდ ინტერესის გამო ვთხოვე ახსნა ანუ სერიოზულად გამახოხა მაგ ამოცანით მაგრამ ეგ არაფერიო უბრალოდ მაინტერესებდა ეგეთ რამეები საერთოდ გიკეთებია თუ არა როდესმეო… ეს ინტერვიუც დასრულდა…

ინტერვიუ მეოთხე:

წინა ინტერვიუს დასრულებამდე, ოთახში შემოვიდა ახალგაზრდა ბიჭი რომელიც მანამდე დილით გავიცანი, სასწრაფოდ შეგვაწყვეტინა ინტერვიუ. მომკიდა ხელი და სადღაც გამაქანა თან რუსულად ქაქანებდა გაუჩერებლად სანამ გონს მოვედი თავი ამოვყავით კრაკოვის ცენტრალურ მოედანზე ერთ ერთ “ზავედენიაში” დაახლოვებით ერთი საათი გავატარეთ იქ სადაც ჩემმა თანმხლებმა შინაურულად მომიგვარა და უპრობლემოდ დამტყუა დამატებითი ინფორმაცია ჩემს შესახებ, ჩემი ცოდნისა და გამოცდილების შესახებ და ჩემი გუგლისადმი დამოკიდებულების შესახებ… ასევე გაარკვია ჩემი ოჯახური მდგომარეობა. მოკლედ თავიდან ვერ მივხვდი მაგრამ ვიეჭვე რომ ესეც ინტერვიუ იყო, რაც მოგვიანებით დადასტურდა

ინტერვიუ მეხუთე:

ამჯერად ბელორუსიელი მათემატიკოსის მსხვერპლი გავხდი. მიუხედავად იმისა რომ მათემატიკა არ ვიცი მაგ ერთ საათსაც წარმატებით გავუძელი და ჩემის აზრით ერთერთი ყველაზე საინტერესო ინტერვიუ იყო. საბოლოოდ ყველაფერი დამთავრდა იმით რომ რაღაც უცნაური პლოტერი გამოვიგონეთ დავაპროგრამეთ და ავამუშავეთ(რა თქმა უნდა თეორიულად) ეს ახალგაზრდაც ღიმილით დამემშვიდობა და წავიდა..

ინტერვიუ მეექვსე:

ეს ინტერვიუ ყოვლად არასაინტერესო იყო ჩემთვის… ორი გოგონა რომლებიც ე.წ. ფრონტ ენდ ინჟინრებად წარმომიდნენ საკმაოდ სუსტები აღმოჩნდნენ.. ამ ბოლო ინტერვიუზე სრულად ვაკონტროლებდი ორივეს და ყოველგვარი გადაჭარბების გარეშე მე თვითონ მიმყავდა ინტერვიუ იმ მიმართულებით რაც უფრო საინტერესოდ მიმაჩნდა… ბევრ საკითხზე საკმაოდ დეტალური განმარტებების გაკეთება მომიწია იმიტომ რომ უაზროდ მეკამათებოდა ერთერთი(შესაძლებელია სპეციალურადაც, თუმცა არ ვიცი). ბოლოს კი ძალიან უცნაური რამ გააკეთეს, ჯავა – ზე კლასის დაწერა მომთხოვეს რომელიც გარკვეული გამოსახულებების მანიპულაციის საშუალებას მისცემდა მათ და ექნებოდა ორნაირი ქცევის უნარი: 1) შეასრულებდა გამოსახულებას და დააბრუნებდა შედეგს; 2) ამ გამოსახულებას ეკრანზე გამოსაბეჭდ სახეს მისცემდა; ეს ამოცანა დაახლოვებით ხუთ წუთში გადავჭერი და ამით დასრულდა ინტერვიუ..

ამ ინტერვიუების შემდეგ, მითხრეს რომ რვავე ინტერვიუერმა უნდა დაწეროს თავისი ანგარიში ხოლო შემდგომ უკვე სხვებმა გადაწყვიტონ ჩემთან გასაუბრების შედეგი. მოკლედ პასუხი უახლოვეს ორ კვირაში მეცოდინება.

შემდეგ, გუგლის ოფისიდან პირდაპირ აეროპორტში გავიქეცი რადგან უკვე მაგვიანდებოდა და დავბრუნდი სამშობლოში

ასე დასრულდა ჩემი ხანმოკლე მაგრამ ძალიან საინტერესო ვიზიტი გუგლთან იმედია ამ მონათხრობიდან თქვენთვის საინტერესოს იპოვით

P.S.
სურათების გადაღების ნება არ დამრთეს სამწუხაროდ ასეთი უცნაური წესი აქვთ… მაინც მოვახერხე რამდენიმეს გადაღება მაგრამ მთხოვეს რომ არ გავავრცელო ინტერნეტის მეშვეობით… ამიტომ იძულებული ვარ თავი შევიკავო მათი აგ დადებისგან…

Update: კრაკოვის სურათები

Update:

დამირეკეს გუგლიდან და სამწუხაროდ უარი მითხრეს… მიზეზი? low level ინჟინერი გვჭირდება ამ ეტაპზე უფროო

მოკლედ ამჯერად ვერ გავუძელი სათანადოდ გამოცდას, თუმცა გული არ მწყდება… ნებისმიერ შემთხვევაში უზარმაზარი გამოცდილება იყო ჩემთვის. რაზეც არცერთი წამით არ ვნანობ და ჩემს კარიერაში ერთერთ უმნიშნველოვანეს მოგონებად დარჩება ყოველთვის

რიგი თქვენზეა B-)

jQuery – მორიგი დიდი აღიარება 2

იოსები — Mon, 29 Sep 2008 05:59:23 +0000

თითქმის ერთი წელი გავიდა მას შემდეგ რაც jQuery – ს დიდ აღიარებაზე დავპოსტე. ამ JavaScript ბიბლიოთეკას ჩემი ადვოკატობა ნამდვილად არ ესაჭიროება, მაგრამ, ამჯერად მისი აღიარების ძალიან მნიშვნელოვან ფაქტს აქვს ადგილი და არ შემიძლია არ დავწერო

jQuery – ს ოფიციალურ ბლოგზე ბოლო პოსტი ამ ღირსშესანიშნავ მოვლენას ეძღვნება: jQuery, Microsoft, and Nokia

Microsoft თავის ცნობილ ASP.NET Ajax ფრეიმვორკს სწორედ jQuery – თი გააფართოვებს და იგი გავრცელდება ვიჟუალ სტუდიოსთან ერთად. Nokia კი თავის Web Run-Time – ს გაამდიდრებს ამ ბიბლიოთეკით.

ასევე ამ თემას ეხება და ძალიან საინტერესოა GWTQuery(jQuery – ის მსგავსი იმპლემენტაცია) რომელიც GWT – ს ბოლო რელიზის პრეზენტაციის დროს აშკარად აქცენტირებული იყო

მანამდე რომ YUI – შიც დაამატეს ე.წ “query selector” – ის იმპლემენტაცია მაგაზე აღარაფერს ვამბობ… მთავარი ერთია, რომ ის მიდგომა რომელიც შეიმუშავა ჯონ რეზიგმა, დომინანტი აღმოჩნდა დღევანდელ JavaScript ბიბლიოთეკების გადატვირთულ ბაზარზე. არადა როგორ მწარედ მახსოვს რამდენჯერ მიკამათია მწარედ როგორც .Net – ის, ასევე GWT – სა და YUI – ს თაყვანისმცემლებთან jQuery – ის უპირატესობაზე… მაგრამ უშედეგოდ თუმცა როგორც იტყვიან აღდგომა და ხვალეო, დრომ ყველაფერი დაამტკიცა და თავის ადგილზე დააყენა…

Long Live jQuery

PHP 5.3 alpha1 – ცვლილებები ენაში

იოსები — Thu, 28 Aug 2008 13:14:14 +0000

მაშ ასე, ცხოვრება წინ მიიწევს და რა თქმა უნდა ტექნოლოგიებიც ვითარდება… აგვისტოს დასაწყისსში გამოჩნდა PHP – ს ახალი 5.3 ალფა ვერსია რომელშიც ენის უმნიშვნელოვანესი გაუმჯობესებებია შეტანილი. თუმცა ამ ფაქტის შესახებ დაწერა ვერ მოვასწარი… ჯერ ქალაქში არ ვიყავი, შემდეგ კი ყველასათვის ის ავადსახსენებელი მოვლენები დაიწყო…

თუმცა, მიუხედავად ყველაფრისა ცხოვრება გრძელდება და მეც ვცდილობ დავუბრუნდე ჩვეულ რითმს, რასაც ამ მცირე მიმოხილვით დავიწყებ

მიმდინარე წლის დასაწყისში ენდი გუტმანსმა გააკეთა გარკვეული პროგნოზები თუ როგორი იქნებოდა ტექნოლოგიუირი 2008 წელი

გარკვეული პერიოდის შემდეგ Google – ს თანამშროლმელმა და ajaxian.com – ის რედაქტორმა, Dion Almaer – მა, დაწერა საპასუხო პოსტი – Andi Gutmans Predicts – ენდის პროგნოზების შესახებ… რომლის ბოლო აბზაციც თავად PHP – განვითარებასა და მომავალს ეხება:

I wonder what 2008 will be like for PHP, Andi. I have no doubt that it will continue to power a huge number of websites. But, what is PHP doing in 2008 to increase its share in the non-hacker-kiddie crowd? Is the Zend Framework going to compete with Rails and the like? How is PHP going to evolve? I want to be able to do richer DSLs with full open classes and meta-support.

გადაიდგა თუ არა რაიმე ნაბიჯები PHP – ს განვითარებისთვის? დიახ გადაიდგა, და ჩემის აზრით საკმაოდ მნიშვნელოვანი ნაბიჯები… ყველა PHP – ს მომხმარებელმა კარგად იცის თუ რამდენი სასარგებლო ფუნქცია და ბიბლიოთეკა გააჩნია ამ ენას. სწორედ ეს მზამზარეული დეტალები ქმნის პროგრამირების კომფორტს, თუმცა ამ დადებითი დეტალების მიღმა PHP როგორც ენა საკმაოდ შეზღუდულია. მეხუთე ვერსიაში განხორციელებული ნახტომი რომელიც მოიცავდა OOP – ს საგრძნობ გაუმჯობესებას მაინც არ არის საკმარისი იმისათვის რომ PHP – სგან უფრო მეტი არ მოვითხოვთ…

მაშ ასე რა ცვლილებებთან გვაქვს საქმე?

Namespace

ნეიმსპეისები, რომელიც პირველი PHP 5 – ის ალფა რელიზში იყო და შემდეგ უკვე გაუგებარი მიზეზების გამო რამდენიმე წლით გაქრა… ეს არის ძალიან, ძალიან სასარგებლო თვისება ენისა კოდის უკეთესი ორგანიზებისათვის. იგივე შესაძლებლობა გვხდება C# – ში, ანალოგიური სახელით და ასევე Java – ში პაკეტების სახელით.

Late Static Bindings და __callStatic()

სტატიკური გვიანი დაკავშირება. OOP – ს მცოდნეთათვის არ არის უცხო გვიანი დაკავშირების(Late Binding) კონცეფცია, და დამეთანხმებით რომ იგი მიეკუთვნება ობიექტზე ორიენტირებული პრინციპების ერთერთ უმნიშვნელოვანეს შესაძლებლობათა რიცხვს. PHP – ში გვიანი დაკავშირება აქამდე ვრცელდებოდა მხოლოდ ობიექტების იერარქიის კონტექსტში. ამიერიდან ეს უკვე შესაძლებელია სტატიკური მემკვიდრეობის კონტექსტშიც. ჩემის აზრით ენის ეს ახალი შესაძლებლობა ძალიან მნიშვნელოვანია.

ასევე ამ განახლების რიგს მიეუკთვნება ე.წ. ჯადოსნური(magic) __callStatic მეთოდის გამოჩენა… PHP 5 – ის მცოდნეთათვის არ არის უცხო __call ჯადოსნური მეთოდი რომელიც გამოიძახება არ არსებულ მეთოდზე მიმართვის შემთხვევაში, და იგი ძალიან მოქნილი მექანიზმია მსგავსი სიტუაციების კონტროლისათვის. __call მეთოდი მასიურად არის გამოყენებული PHP – ს SOAP გაფართოვებაში. ვისაც გიმუშავიათ ამ გაფართოვებასთან გამოცდილი გექნებათ აღნიშნული მეთოდის სიმძლავრე… თუმცა აქამდე ეს მეთოდი მხოლოდ ობიექტის კონტექსტში მუშაობდა და სტატიკურ კონტექსტში მისი გამოყენების არანაირი შანსი არ არსებობდა… ახალი ჯადოსნური __callStatic მეთოდით, რომელიც გამოჩნდა ამ განახლებაში უკვე კლასის სტატიკურ კონტექსტსაც გაცილებით უფრო მოქნილსა და სასარგებლოს გახდის.

Lambda functions and closures

ანონიმური ფუნქციები(closures) ეს არის ჩემის აზრით ერთერთი უმნიშვნელოვანესი დამატება ენისათვის, რაც ბევრად უფრო მეტ მოქნილობას შესძენს PHP – ს. არანაირად არ მეპარება ეჭვი რომ ენის ეს შესაძლებლობა ნებისმიერი გამოცდილი სკრიპტული ენის პროგრამისტის ხელში უმნიშვნელოვანესი ინსტრუმენტი იქნება. განსაკუთრებით სასიხარული ეს შესაძლებლობა იქნება ისეთი პროგრამისტებისათვის ვისაც აქვს JavaScript – თან ან Python – თან მუშაობის გამოცდილება.

თუმცა იგივე JavaScript – ისგან განსხვავებით, არსებობს რამდენიმე ისეთი დეტალი რაც ყურადღებას იმსახურებს… ეს გამოწვეულია ამ ენებს შორის არსებული სკოუპების იმპლემენტაციის განსხვავების გამო. ანუ PHP – ს ანონიმური ფუნქციის გარკვეულ სკოუპში აღწერისას ავტომატურად არ უზრუნველყოფს მის მშობელ სკოუპში აღწერილი ცვლადების ხილვადობას. ამისათვის გამოიყენება სპეციალური use კონსტრუქცია რომელშიც უნდა მოხდეს საჭირო ცვლადების მითითება:

   function replace_in_array ($search, $replacement, $array) {
     $map = function ($text) use ($search, $replacement) {
       if (strpos ($text, $search) > 50) {
         return str_replace ($search, $replacement, $text);
       } else {
         return $text;
       }
     };
     return array_map ($map, $array);
   }

ასევე საგულისხმოა კლასებში _ _invoke ჯადოსნური მეთოდის გამოჩენა. ეს მეთოდი ე.წ. callable object კონცეფციის ნაწილია. ქვემოთ მოყვანილ კოდში ნაჩვენებია ამ მეთოდის გამოყენების მაგალითი:

class Example {
  public function __invoke () {
    echo "Hello World!\n";
  }
}
$foo = new Example;
$foo ();

enjoy

LinGO – ინგლისურ/ქართული ლექსიკონი iPhone – სთვის

იოსები — Tue, 05 Aug 2008 12:15:54 +0000

რამდენიმე დღით ქალაქიდან ვიყავი გასული, და როგორც იქნა მოვიცალე iPhone SDK – სთვის. რამდენიმე დღიანი ექსპერიმენტების შემდეგ პირველი რეალური აპლიკაცია შევქმენი

ძალიან აზარტული პროცესი აღმოჩნდა iPhone – სთვის წერა. მართალია iPhone SDK არ იძლევა აპლიკაციების წერის ისეთ კომფორტს როგორც ეს ჩვეულებრივი Mac OS X – ისთვის წერის დროს გვაქვს, მაგრამ თუ დამიჯერებთ მაინც საკმაოდ სასიამოვნო პროცესი აღმოჩნდა

ამჯერად არ შეგაწყენთ თავს Objective-C – ს და Cocoa Touch – ის დეტალებზე საუბრით. თუმცა ეს ძალიან საინტერესო თემაა და იმედია გამოვნახავ დროს და ამ თემის ირგვლივ შეძლებისდაგვარად საინტერესო პოსტებს შემოგთავაზებთ.

რაც შეეხება პროდუქტს იგი ფუნქციონალურად აბსოლუტურად გამართულია, არ აღენიშნება ბაგები და მუშაობს სტაბილურად. უახლოვეს დღეებში, როდესაც ისევ მოვიცლი, აუცილებლად დავდებ მისი ინსტალაციის ინსტრუქციას.

ჯერჯერობით მხოლოდ iPhone – ს სიმულატორშია გატესტილი, მე კი სამწუახაროდ iPhone – ზე ოპერაციული სისტემის 1.3 ვერსია მიყენია. iPhone SDK კი მხოლოდ ოპერაციული სისტემის 2.0 ვერსიას ითვალისწინებს

ამიტომ როგორც კი შევძლებ ტელეფონზე რეალური ტესტირების ჩატარებას, მაშინათვე ხელმისაწვდომს გავხდი ამ პროდუქტს.

მანამდე კი შეგიძლიათ ეს სურათები დაათვალიეროთ და გამიზიაროთ თქვენი მოსაზრებები

Cuil(a.k.a cool) vs Google Competition

იოსები — Mon, 28 Jul 2008 12:03:21 +0000

დღეს Techcrunch – ზე გაჟღერდა ამ უცნაური სახელის მქონე ახალი საძიებო სისტემის შესახებ სახელად Cuil!

ვითომ მართლა გამოუჩნდა კონკურენტი Google – ს? ჯერჯერობით მართლა ადრეა ამ საკითხზე ლაპარაკი. რადგან შეუძლებელია სულ რაღაც რამდენიმე თვის შექმნილმა, და რამდენიმე საათის გაშვებულმა სისტემამ ასე უეცრად აჯობოს Google – ს ნაირ მონსტრს.

მაგრამ, როგორც დავად Cuil – ის ( ) საიტზე წერია:

Welcome to Cuil—the world’s biggest search engine. The Internet has grown. We think it’s time search did too.

ეს არის მსოფლიოს უდიდესი საძიებელი სისტემა… თუ ცოტა ხანი გაეთამაშებით მას, მიუხედავად სიმპატიურად დალაგებული რეზულტატებისა მას საკმაოდ ბევრი რამ აკლია თუმცა, ზოგადად, რამდენად მნიშვნელოვანია ეს მომენტი?

ჩემი პირადი აზრით და ღრმა რწმენით საჭიროა ისეთ მაღალხარისხიან მონსტრსაც ჰყავდეს კონკურენტი როგორიც არის ყველასათვის კარგად ცნობილი და “საყვარელი” Google. ალბათ კონკურენციის შანსები რეალურია რადგან ეს სისტემა სწორედ ექს გუგლერების მიერ არის შექმნილი!

Enjoy Cuil B-)

Updated: Cuil – ის ავტორი

Updated: ერთი საინტერესო დეტალი, ეხლა აღმოვაჩინე რომ, თუ რაიმე სიტყვას ან ფრაზას ვერ პოულობს სისტემა, მაქსიმუმ ნახევარ საათში იგივე სიტყვისთვის/ფრაზისთვის უკვე რეზულტატი გვხვდება… რა პრინციპით და რატომ ხდება ასე უცნობია

Beyond REST? Building data services with XMPP

იოსები — Sun, 27 Jul 2008 15:03:08 +0000

ძალიან საინტერესო და დამაინტრიგებელი პრეზენტაცია XMPP – სა და ReST – ის შესახებ.

არ ვიცი რამდენად ხართ დაინტერესებული ვებ სერვისებით და კონკრეტულად ReST – ით(SOAP Definitely SUCKS), მაგრამ დიდი ენთუზიაზმით განვიხილავდი ამ თემას თქვენთან ერთად

მერწმუნეთ არ წააგებთ თუ დახარჯავთ დროს და ამ პრეზენტაციას გულდასმით გაეცნობით. შესაძლოა ყველა არ დაეთანხმოს პრეზენტაციის ავტორების დასკვნებს და მოსაზრებებს, მაგრამ, ნებისმიერ შემთხვევაში ძალიან საინტერესო ინფორმაციას მიიღებთ.

ასევე გადახედეთ del.icio.us – ის ავტორის მოსაზრებებს ამ თემაზე: Beyond rest

Beyond REST? Building data services with XMPP

view presentation (tags: oscon jabber rest xmpp)

საინტერესო JavaScript ტესტი meebo.com – ზე

იოსები — Wed, 23 Jul 2008 23:28:48 +0000

ეხლახანს meebo.com – ზე შევიარე, და რატომღაც ვაკანსიების განყოფილებას გადავხედე, დამაინტერესა რა პოზიციებზე აქვს ვაკანსიები ამ კომპანიას… ერთერთი აღმოჩნდა javascript engineer (javascript ninja) და რატომღაც გადავხედე

პოსტში, ვაკანსიის აღწერის გარდა მითითებულია რამდენიმე JavaScript – თან დაკავშირებული შეკითხვა, და შევეცადე პასუხები გამეცა, ჩემის აზრით ეს დაგაინტერესებთ:

1. When does div.setAttribute(“###”) not equal div.###?

საკმაოდ მარტივი შეკითხვაა რადგან MDC – ს დოკუმენტაციაში პირდაპირ წერია, რომ, DOM ელემენტს ატრიბუტის შექმნის და მისთვის საწყისი მნიშნველობის მინიჭების აუცილებლობის შემთხვევაში უნდა გამოვიყენოთ el.setAttribute(attName, attValue); მეთოდი. ხოლო ამ ატრიბუტის მნიშვნელობის შემდეგი ცვლილებისათვის უნდა გამოვიყენოთ ელემენტის თვისება, ანუ: el.attName = attValue და არა setAttribute მეთოდი;

ციტატა დოკუმენტაციის გვერდიდან:

Using setAttribute() to modify certain attributes, most notably value in XUL and HTML and selected in HTML, works inconsistently, as the attribute specifies the default value. To access or modify the current values, you should use the properties. For example, use elt.value instead of elt.setAttribute(‘value’, val).

2. What’s the difference between these two statements:
a. var x = 3;
b. x = 3;

ეს შეკითხვაც არ მიეკუთვნება რთულ კატეგორიას. var ქივორდის გამოყენება ცვლადის აღწერის წინ მისი სკოუპის(გლობალური, ფუნქციის, კლასის) ფიქსაციისათვის გამოიყენება. ხოლო თუ არარსებულ ცვლადს მივანიჭებთ მნიშვნელობას var – ის გამოყენების გარეშე, მაშინ ეს ცვლადი გლობალურ კონტექსტში მოხვდება.

3. What’s the difference between:
a. !!(obj1 && obj2)
b. (obj1 && obj2)

ამ შემთხვევაში ნაჩვენებ ორ გამოსახულებას შორის მგონი არანაირი განსხვავება არ უნდა იყოს. a ვარიანტში, გამოსახულების წინ მითითებული ორი ძახილის ნიშანი(!!) ნიშნავს შემდეგს: მარჯვენა ძახილის ნიშანი (obj1 && obj2) გამოსახულების დაიყვანს boolean ტიპზე და შეცვლის მას საპირისპირო მნიშვნელობით(ანუ თუ გამოსახულების შედეგია false საპირისპირო მნიშვნელობა იქნება true და პირიქით), ხოლო მარცხენა ძახილის ნიშანი კვლავ შეცვლის ამ საპირისპირო მნიშვნელობას შესაბამისად.

a შემთხვევაში (obj1 && obj2) გამოსახულება ნებისმიერ შემთხვევაში დააბრუნების boolean ტიპის მნიშნველობას && – ის გამო, ხოლო ზემოთ აღწერილი ძახილის ნიშნების გამოყენება საბოლოო ჯამში მაინც იგივე შედეგს მოგვცემს.

რადან b შემთხვევაშიც a – ს მსგავსად, გამოსახულება აუცილებლად აბრუნებს boolean ტიპის მნიშვნელობას, ეს ნიშნავს იმას რომ ამ ორ გამოსახულებას შორის არანაირი განსხვავება არ არსებობს.

4. Write a one-line piece of JavaScript code that concatenates all strings passed into a function:
function concatenate(/*any number of strings*/) {
    var string = /*your one line here*/
    return string;
}

ეს შეკითხვა ძალიან საინტერესოა. პირობა მოითხოვს რომ, concatenate() ფუნქციისათვის გადაცემული ნებისმიერი რაოდენობის სტრიქონული ტიპის პარამეტრის კონკატენაცია მოხდეს ერთი სტრიქონი კოდით. JavaScript – ში ფუნქციის გამოძახების დროს, მას შეგვიძლია გადავცეთ ნებისმიერი რაოდენობის პარამეტრი. ფუნქციისათვის გადაცემული ყველა პარამეტრი ინახება arguments ობიექტში ჩამონათვალის სახით. ერთი შეხედვით arguments ობიექტი მასივს წააგავს, მაგრამ სინამდვილეში იგი ნამდვილი მასივი არ არის. გამომდინარე აქედან, არგუმენტების გაერთიანებას Array ობიექტის join() მეთოდის გამოყენებით ვერ შევძლებთ… რადგან arguments ობიექტს Array ობიექტის მეთოდები არ გააჩნია.

ამისათვის მოგვიწევს მსგავსი კოდის დაწერა:

function concatenate() {
    var string = Array.prototype.join.call(arguments);
    return string;
}

alert(concatenate('s1', 's2', 's3', 's4'));

გამოსავალი მდგომარეობს ფუნქციის call მეთოდის გამოყენებაში(იხ. პოსტი call და apply მეთოდების შესახებ).

პირველ რიგში Array ობიექტის join მეთოდს მივმართავთ prototype თვისების მეშვეობით. ხოლო შემდეგ ვიძახებთ ფუნქციის call მეთოდს, რომელსაც პირველ პარამეტრად გადაეცემა კონტექსტი. ამიტომ join() მეთოდის შესრულება მოხდება უშუალოდ arguments ობიექტის კონტექსტში, რაც თავის მხრივ join() მეთოდს წვდომას მისცემს arguments ობიექტის ყველა თვისებაზე. გამომდინარე იქედან რომ, arguments ობიექტი არის იტერირებადი, და მას გააჩნია length თვისება(რომელიც ასევე გააჩნია Array ობიექტს), join() მეთოდს ეძლევა იმის საშუალება რომ arguments ობიექტის ელემენტები დააჯგუფოს. შედეგად მივიღებთ ასეთ “s1,s2,s3,s4″ კონკატენირებულ სტრიქონს.

5. What do these two examples have in common?

Example 1:

var obj = document.getElementById('adiv');
document.getElementById('adiv').ptr = obj;

Example 2:

function assignClick() {
    var el = document.createElement('div');
    function handleClick() {
        el.innerHTML = 'clicked!';
    }
    el.attachEvent("onclick", handleClick);
}

ხო, ამ შეკითხვამ ცოტა არ იყოს დამაბნია, და არ ვიცი რამდენად სწორად მივხვდი. თუ თქვენს მოსაზრებებს მომაშველებთ ძალიან გამახარებთ

რამდენადაც მე ვვარაუდობ, პირველ მაგალითში DOM ელემენტის .ptr თვისებას უბრალოდ ვანიჭებთ obj ობიექტს.

მეორე მაგალითშიც იგივესთან უნდა გვქონდეს საქმე, რადგან attachEvent არის ივენთებთან მუშაობის IE – ს მოდელი რომელიც არცერთ სხვა ბრაუზერში არ გვხვდება. ნაჩვენებ კოდსა el.attachEvent(“onclick”, handleClick) და el.onclick = handleClick ამ კოდს შორის კი არანაირი განსხვავება არ არსებობს. W3C მოდელისგან განსხვავებით IE – ს attachEvent ზუსტად იგივეს აკეთებს რაც ელემენტის თვისებაზე ობიექტის მინიჭებაა(იხ. განსხვავება IE და W3C მოდელებს შორის). ამ განსხვავების საფუძველზე ვივარაუდე ეს პასუხი, თუმცა დარწმუნებული ნამდვილად არ ვარ.

Update: სწორი პასუხი იხილეთ კომენტარებში, მთელი წინა(წაშლილი) აბზაცი წარმოადგენს სრულ სისულელეს

PHP: nl2p(aragraph) vs nl2br

იოსები — Fri, 18 Jul 2008 15:51:49 +0000

როგორ იქცევით ისეთ შემთხვევაში, როდესაც საჭიროა HTML textarea ელემენტიდან მიღებული ტექსტის, HTML დოკუმენტში უცვლელად გამობეჭვდაა საჭირო ანუ ტექსტის ფორმატირების გათვალისწინებით?

ამ შემთხვევაში, ტექსტის აბზაცებად ფორმატირებას ვგულისხმობ, სადაც აბზაცების გამოყოფად იგულისხმება ახალი სტრიქონის სიმბოლო.

მაგალითად ასეთი ტექსტი:

ეს არის ჩვეულებრივი აბზაცი.

ეს არის შემდეგი აბზაცი...

და კიდევ ერთი აბზაცი..

ამ შემთხვევაში ტექსტის გამოსაბეჭდად გამოვიყენე

 ტეგი, რომელიც ტექსტს ახალი სტრიქონის სიმბოლოების გათვალისწინებით ბეჭდავს და არ უკარგავს მას ფორმატირებას. თუმცა,  სრულიად გამოუსადეგარია ბლოგ პოსტის ან ამ ბლოგის მომხმარებლების მიერ დაპოსტილი კომენტარების გამოსატანად.
PHP – ს გააჩნია ფუნქცია სახელად nl2br რომელსაც ყოველი ახალი სტრიქონის სიმბოლო გადაჰყავს 
 ტეგში, თუმცა არც ეს არის დიდი ხეირი რადგან,

როგორც HTML სპეციფიკაცია გვეუბნება, აბზაცების ფორმატირებისათვის უნდა გამოვიყენოთ 
 ტეგი, თუმცა PHP – ს ასეთი ფუნქცია არ გააჩნია.
მარტივი რეგულარული გამოსახულების დახმარებით მივიღე ასეთი ფუნქცია, რომელიც აღწერილ პრობლემას მარტივად და სწრაფად აგვარებს:
1
2
3
function nl2p($input) {

    return preg_replace('~^\s*(.*?)\s*$~smx', '$1
', $input);

}
თუ ამ ფუნქციას გამოვიყენებთ ზემოთ მოყვანილი ტექსტის დასამუშავებლად, მივიღებთ ასეთ შედეგს:
ეს არის ჩვეულებრივი აბზაცი.
ეს არის შემდეგი აბზაცი...
და კიდევ ერთი აბზაცი..

აღსანიშნავია რომ, ეს ფუნქცია იგნორირებას უკეთებს ერთმანეთის მიყოლებით აკრეფილ ახალი სტრიქონის სიმბოლოებს.
როგორ მუშაობს თავად რეგულარული გამოსახულება:
$regex = '~
    ^            # 1) შევამოწმოთ სტრიქონის დასაწყისი
    \s*          # 2) ნებისმიერი რაოდენობის უხილავი სიმბოლო
    (.*?)        # 3) ნებისმიერი რაოდენობის ნებისმიერი სიმბოლო
    \s*          # 4) ნებისმიერი რაოდენობის უხილავი სიმბოლო
    $            # 5) შევამოწმოთ სტრიქონის დასასრული
~smx'            # 6) smx - გამოსახულების მოდიფიკატორები

ბრჩხილებში მოქცეული გამოსახულების მესამე პუნქტის მეშვეობით ვინახავთ ჩვენთვის საჭირო ტექსტს, იმისათვის რომ მოგვიანებით შევძლოთ მისი გამოყენება, გამოსახულების დანარჩენი ნაწილი კი უბრალოდ ტექსტის შემოწმებისათვის არის საჭირო.
თავად გამოსახულებაზე უფრო საინტერესო მოცემულ შემთხვევაში არის, გამოყენებული რეგულარული გამოსახულების მოდიფიკატორები s და m.
. – წერტილი, რეგულარულ გამოსახულებაში ნიშნავს ნებისმიერ სიმბოლოს ახალი სტრიქონის სიმბოლოს გარდა. ხოლო s მოდიფიკატორი გამოსახულების ბოლოს წერტილს უცვლის მნიშვნელობას და იგი უკვე სხვა ნებისმიერ სიმბოლოსთან ერთად ახალი სტრიქონის სიმბოლოებსაც მოიცავს. 
m მოდიფიკატორი თავის მხრივ ცვლის ტექსტის დასაწყისისა(^) და ტექსტის დასასრულის($) სიმბოლოების ქცევას. რაც ნიშნავს იმას, რომ, ეს სიმბოლოები მიუთითებენ არა მთლიანი ტექსტის დასაწყისსა და დასასრულს არამედ ახალი ხაზის სიმბოლოთი გამოყოფილ სტრიქონის დასაწყისსა და დასასრულს.
გამოსახულებაში ასევე მნიშვნელოვანია მეორე და მეოთხე პუნქტები. გამოსახულება უბრალოდ აღნიშნავს ნებისმიერი რაოდენობის უხილავ სიმბოლოს(უხილავ სიმბოლოებს განეკუთვნება ახალი სტრიქონის სიმბოლოც). გამოსახულების ეს ნაწილია საჭიროა იმისათვის რომ ტექსტში არსებულ ერთზე მეტ ახალი სტრიქონის სიმბოლოებს გავუკეთოთ იგნორეირება რათა არ მივიღოთ ცარიელი 
p
 ტეგების კომბინაცია. 
სულ ეს არის და ეს