განავითარეთ თანამედროვე ვებ აპლიკაციები Dart-ით

ეს სტატია პირველად გამოჩნდა .net ჟურნალის 234 ნომერში - მსოფლიოში ყველაზე გაყიდვადი ჟურნალი ვებ დიზაინერებისა და დეველოპერებისთვის.

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

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

ფილოსოფია და მოტივაცია

ვებ პლატფორმა სწრაფად ვითარდება, ბრაუზერის გუნდები და სტანდარტების კომიტეტები ამუშავებენ უამრავ საინტერესო ფუნქციას. HTML5 ტექნოლოგიების ოჯახი მოიცავს WebGL ტექნიკით დაჩქარებული 3D-სთვის, FileSystem API ფაილების მართვისთვის და დირექტორიები, Web Audio API მრავალარხიანი დაბალი შეყოვნების აუდიოსთვის, getUserMedia ვებკამერისა და მიკროფონის წვდომისთვის – და მეტი. თანამედროვე JavaScript ძრავებს, უფრო სწრაფად ყოველი გამოშვებით, შეუძლიათ შთამბეჭდავი აპლიკაციების მართვა.

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

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

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

ბრაუზერის მხარდაჭერა

Dart აწყობს თანამედროვე JavaScript-ს (ES5+) და, შესაბამისად, მიზნად ისახავს თანამედროვე ბრაუზერებს, როგორიცაა IE9+, Firefox, Chrome, Safari და Opera. ასევე მხარდაჭერილია მობილური ბრაუზერები, როგორიცაა Safari Mobile და Chrome for Android. Dart-ის ვირტუალური მანქანა ჯერ არ არის Chrome-ში და არც სხვა ბრაუზერებს გამოუთქვამთ აშკარა მხარდაჭერა მისი ჩანერგვისთვის წერის დროს, მაგრამ ეს არ არის Dart-ის მიღების ბლოკერი. ჩვენ ველით, რომ Dart VM საბოლოოდ გახდება Chrome-თან ინტეგრირებული, მაგრამ აუცილებელია Dart-ის შედგენა JavaScript-ზე, რათა მისი გამოყენება შესაძლებელი იყოს თანამედროვე ვებზე.

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

Dart პროექტის კომპონენტები

Dart უფრო მეტია, ვიდრე უბრალოდ ენა: ეს არის მთელი პლატფორმა. აქ არის კომპონენტების სია Dart პროექტისგან:

• Dart ენა ნაცნობი, ობიექტზე ორიენტირებული კლასზე დაფუძნებული ენაა.
• Core Dart ბიბლიოთეკები მოიცავს კლასებსა და ფუნქციებს კოლექციებისთვის, ძირითადი ტიპებისა და სერვერის (ფაილები, დირექტორიები, HTTP) და კლიენტის (HTML5) აპების ფუნქციონალურობას.
• გაფართოებული Dart ბიბლიოთეკები მოიცავს ინტერნაციონალიზაციას, ერთეულების ტესტირებას, არგუმენტების გარჩევას - და ბევრ სხვას.
• ბრაუზერის პროგრამირების გაუმჯობესებული ბიბლიოთეკები DOM პროგრამირებას Dart პროგრამირებას ჰგავს.
• Dart Editor არის მდიდარი რედაქტორი, რომელიც გეხმარებათ Dart აპების დაწერაში, გაშვებასა და გამართვაში.
• Dart ვირტუალური მანქანა, ან VM, გაშვება Dart კოდს მშობლიურად. ის შეიძლება იმუშაოს ბრძანების სტრიქონზე ან შეიძლება იყოს ჩასმული ვებ ბრაუზერში.
• dart2js აგროვებს Dart კოდს JavaScript-ში ყველა თანამედროვე ბრაუზერისთვის.
• dart_analyzer არის სტატიკური ანალიზატორი, რომელსაც შეუძლია Dart კოდის გაანალიზება და პოტენციური შეცდომებისა და გაფრთხილებების მოხსენება.
• Dartium არის Chromium-ის მორგებული კონსტრუქცია ჩაშენებული Dart VM-ით. Dartium-ს შეუძლია Dart აპლიკაციების გაშვება ბუნებრივად, JavaScript-ში პირველად შედგენის გარეშე.
• პაბი არის Dart პაკეტის მენეჯერი. გამოიყენეთ pub მესამე მხარის Dart ბიბლიოთეკების დასაყენებლად.

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

Ენა

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

კლასები

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

// Pull in the math library that ships with the Dart SDK. import 'dart: math', prefix: 'Math'; class Point {
final num x, y; // A constructor, with shorthand for setting instance fields. Point(this.x, this.y); // A named constructor. Point.origin(): x = 0, y = 0; // A method. num distanceTo(Point other) {
var dx = x - other.x; var dy = y - other.y; return Math.sqrt(dx * dx + dy * dy); }
}

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

ზემოთ მოყვანილი მაგალითი აცხადებს ორ კონსტრუქტორს. პირველი გვიჩვენებს მშვენიერ „სინტაქსურ შაქარს“ განმეორებადი ამოცანისთვის, კონსტრუქტორის პარამეტრების დაყენება მაგალითად ველებზე. კონკრეტულად, წერტილი (this.x, this.y) უდრის წერტილი (x, y): this.x = x, this.y = y;. მეორე კონსტრუქტორი დასახელებულია, კონკრეტულად Point.origin(), დამატებითი ინფორმაციის გადმოსაცემად ზარის საიტზე.

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

Dart-ის ყველა პროგრამა იწყება ა მთავარი () ფუნქცია. აი, როგორ ქმნით Point-ის ახალ მაგალითებს:

main() {
var p1 = new Point.origin(); var p2 = new Point(10, 10); print("The distance is ${p2.distanceTo(p1)}"); }

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

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

არჩევითი სტატიკური ტიპები

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

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

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

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

combine(a, b) {
var combination = a + b; return combination; }

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

num combine(num a, num b) {
var combination = a + b; return combination; }

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

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

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

უმაღლესი დონის ფუნქციები

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

makeLouder(String msg) => msg.toUpperCase(); main() {
print(makeLouder("hello, dart")); }

ზემოთ მოყვანილ მაგალითში, => გამოხატულება; არის სტენოგრამა { დაბრუნება გამოხატულება; } და საკმაოდ გამოსადეგია გამოძახებისა და მარტივი ერთი ხაზის ფუნქციებისთვის.

ლექსიკური ფარგლები

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

class ShoutingButton {
final ButtonElement button; ShoutingButton(this.button) {
button.on.click.add((e) => shout()); }
shout() {
print("YOU CLICKED THE BUTTON!!!"); }
}

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

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

makeAdder(num n) {
return (num i) => n + i; }
main() {
var add2 = makeAdder(2); print(add2(3)); // 5. }

იზოლატები

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

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

import 'dart: isolate'; echo() {
port.receive((msg, SendPort replyTo) {
replyTo.send("I received: $msg"); }); }
main() {
// Spawn the echo function into a new isolate. SendPort echoPort = spawnFunction(echo); echoPort.call("Hello from main").then((replyMsg) {
print(replyMsg); // I received: Hello from main. }); }

გამოყენება spawnFunction() ფუნქციიდან ახალი იზოლაციის შესაქმნელად. დაბრუნდა SendPort გამოიყენება იზოლაციაში შეტყობინებების გასაგზავნად. იზოლატორს შეუძლია შეტყობინებების მოსმენა port.receive(). შეტყობინებები კოპირდება მანამ, სანამ ისინი მიიღებენ იზოლატორს, რაც უზრუნველყოფს ორ იზოლაციას შორის არსებული მდგომარეობის გაზიარებას.

ქარხნის კონსტრუქტორები

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

class Singleton {
static Singleton _singleton; factory Singleton() {
if (_singleton == null) {
_singleton = new Singleton._internal(); }
return _singleton; }
Singleton._internal() {
// Initialize the object. }
}

წვდომა სინგლიტონი ადვილია:

main() {
var s1 = new Singleton(); var s2 = new Singleton(); print(s1 s2); // true, the objects are identical. }

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

მეთოდის კასკადები

ეს ფუნქცია არის Smalltalk-დან და ახლა ხელმისაწვდომია Dart-ში. ზოგიერთი API-სთვის, როგორიცაა მშენებლები, შეიძლება დამღლელი იყოს ცვლადის სახელების გამეორება.

canvasContext.beginPath(); canvasContext.fillStyle = penColor; canvasContext.arc(tx, ty, penWidth/2+2, 0, PI2, true); canvasContext.fill(); canvasContext.moveTo(wx, wy); canvasContext.strokeStyle = "black"; canvasContext.lineTo(tx, ty); canvasContext.closePath(); canvasContext.stroke();

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

canvasContext. ..beginPath()
..fillStyle = penColor. ..arc(tx, ty, penWidth/2+2, 0, PI2, true)
..fill()
..moveTo(wx, wy)
..strokeStyle = "black"
..lineTo(tx, ty)
..closePath()
..stroke();

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

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

ბრაუზერის დაპროგრამება

ვებ დეველოპერებმა იციან DOM, რადგან ის არის ენობრივად ნეიტრალური ინტერფეისების ნაკრები, რომელიც ყველგან არის გავრცელებული ვებ ბრაუზერებში. თუმცა, DOM-ის დაპროგრამება არცერთ ენაზე არ არის ძალიან ბუნებრივი. (jQuery-ის გაჩენა ნაწილობრივ აიხსნება იმის გამო, რომ მან DOM-ს JavaScript-ის მსგავსი აგრძნობინა.) Dart პროექტი აშენებს Dart მეგობრულ ბრაუზერის ბიბლიოთეკას ე.წ. ისარი: html რათა დაეხმარონ დეველოპერებს იყვნენ უფრო პროდუქტიულები ბრაუზერის აპების შექმნისას.

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

import 'dart: html'; main() {
// Find the element with ID of 'button'. var button = query('#button'); // Add a click handler. button.on.click.add((e) => print('You clicked ${button.id}')); // Create a new DIV. var message = new DivElement(); // Set an ID. message.id = 'confirmation'; // Add a CSS class. message.classes.add('important'); // Set the contents. message.text = 'Thanks for trying Dart!'; // Attach the message to the body. document.body.elements.add(message); }

Dart იღებს ახალ მიდგომას ბრაუზერის პროგრამირებაში, გადახედავს რამდენიმე ძველ ვარაუდს. მაგალითად, ბოლოს როდის გაგზავნეთ XML XMLHttpმოთხოვნა? ასე გვეგონა. გამარტივების მცდელობისას ჩვენ დავარქვით სახელი XMLHttpRequest რომ HttpRequest.

აქ არის მაგალითი იმისა, თუ როგორ გამოიყენოთ HttpRequest JSON მონაცემების მისაღებად და გასაანალიზებლად:

import 'dart: html'; import 'dart: json'; void main() {
new HttpRequest.get("data.json", (req) {
Map data = JSON.parse(req.response); }); }

შეგიძლიათ მეტი წაიკითხოთ dart: html ბიბლიოთეკა, ან შეისწავლეთ მეტი ნიმუშები.

Dart რედაქტორი

Dart-ის დაპირების მთავარი ადგილი არის ხელსაწყოების შესანიშნავი გამოცდილება. Dart Editor შექმნილია იმისათვის, რომ დეველოპერებს მისცეს ნაცნობი რედაქტირებისა და გამართვის გამოცდილება, დასრულებულია ისეთი ფუნქციებით, როგორიცაა კოდის დასრულება, რეფაქტორირება და სხვა. (თუ IntelliJ-ის ან WebStorm-ის მოყვარული ხართ, შეგიძლიათ სცადოთ JetBrains-ის Dart დანამატი. თუ მოგწონთ Eclipse, შეგიძლიათ სცადოთ Eclipse დანამატი.)

კოდის შევსება

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

რეფაქტორირება

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

გამართვა

გამართვის შესანიშნავი გამოცდილება ტექსტის რედაქტორებს IDE-ებისგან ჰყოფს. Dart Editor აერთიანებს თავის გამართვას Dartium-თან, Chromium-ის კონსტრუქცია Dart VM-თან. შეგიძლიათ დააყენოთ წყვეტის წერტილები, გადალახოთ კოდი, შეამოწმოთ ცვლადები და სხვა.

Ვიწყებთ

• ჩამოტვირთვა Dart რედაქტორი. მასში შედის Dart SDK და Dartium. მისასალმებელი ეკრანი აქვს აპების და ბმულების ნიმუშებს დასაწყებად.
• დააწკაპუნეთ Solar ნიმუშის აპლიკაციაზე და Solar-ის ასლი დაემატება თქვენს რედაქტორს.
• დააწკაპუნეთ მწვანე Run ღილაკს აპის გასაშვებად. რედაქტორი უშვებს Dartium-ს და თქვენ შეგიძლიათ ნახოთ იმიტირებული მზის სისტემა!
• გაუშვით Solar ბრაუზერში Dart VM-ის გარეშე. დააწკაპუნეთ მარჯვენა ღილაკით მზის.დარტი ფაილების ხედში და აირჩიეთ JavaScript-ის სახით გაშვება. ეს შეადგენს Dart აპს JavaScript-ში და გაუშვებს თქვენს ნაგულისხმევ ბრაუზერს.
• თქვენ ახლახან გაუშვით თქვენი პირველი Dart აპლიკაცია! ითამაშე Solar-ის კოდით; რედაქტორი აკეთებს ასლს თქვენთვის. სცადეთ შეცვალოთ პლანეტების ფერები ან გრავიტაციის ფაქტორები.

დასკვნა

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

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

სეთ ლედი არის ვებ ინჟინერი და კონფერენციის ორგანიზატორი.