[მუსიკალური სათამაშო]
ROGER ZURAWICKI: Hi, ჩემი სახელი Roger Zurawicki,
და მე იქნება, რომელიც მოიცავს CS50 Meteor სემინარი.
Meteor არის ახალი ჩარჩო ეძღვნება ახალი ტიპის ვებგვერდი,
არ PHP მიღების მოთხოვნები უკან და მეოთხე სახის
ვებ დავინახეთ PHPP კომპლექტი, მაგრამ უფრო დინამიური JavaScript
ნაწილების ვებ.
რამ Meteor შეუძლია გააკეთოს მოიცავს Live განახლება
და დაუყოვნებლივ კომუნიკაციის მომხმარებელთა შორის იმავე ნახვა.
>> სემინარის, ჩვენ გვაქვს კოდი უმასპინძლა ჩემი GitHub.
თქვენ შეგიძლიათ გადადით ამ URL ჩამოტვირთვა.
თუ იცით, თუ როგორ გამოიყენოთ Git, შეგიძლიათ კლონი საცავი.
თუ თქვენ არ იცით, თუ როგორ გამოიყენოთ Git ან არ გამოიყენება GitHub,
ეს სრულიად ჯარიმა.
მე გაჩვენებთ ძალიან სწრაფად როგორ შეგვიძლია წასვლა GitHub,
და იქ ვარიანტი ჩამოტვირთვა zip უფლება არსებობს.
ერთხელ თქვენ ჩამოტვირთვა დირექტორია, შეიძლება დავიწყოთ ჩვენი კოდი.
>> მეტი ინფორმაცია Meteor შეგიძლიათ იხილოთ meteor.com.
სემინარში საქაღალდეში, მე რეალურად აქვს გარკვეული Meteor პროექტები ჩვენ შეგვიძლია გამოვიყენოთ.
ერთი ფოლდერები გვაქვს სემინარი პროექტი todos app.
ასე რომ, თუ მე წასვლას I, აქვს Meteor დაყენებული.
ასე, რომ აწარმოებს, უბრალოდ უნდა აკრიფოთ Meteor, და Meteor დააყენოთ.
როგორც ხედავთ, ჩვენ უნდა დარწმუნდით, რომ ჩვენ დაყენებული Meteor.
ამიტომ მე უბრალოდ აპირებს აწარმოებს ეს კიდევ ერთხელ
დარწმუნდით, რომ Meteor სწორად დაყენებული.
>> მიუხედავად იმისა, რომ მე მაქვს Meteor დაყენების, შემიძლია გაჩვენოთ
რამდენიმე ცოცხალი demos of Meteor საიტები აპირებს ცოცხალი ახლავე ინტერნეტში.
მე მაქვს დემო ჩვენი app.
თქვენ შეგიძლიათ თქვათ, შემდეგ URL.
ეს არის, რომ გავაკეთოთ app რომ ჩვენ გვაქვს ჩვენი სემინარი დირექტორია.
URL ეს არის rozu-rabbit.meteor.com.
დაინახავთ, რომ Meteor რეალურად უმასპინძლებს თქვენი Meteor პროექტების უფასოდ.
და ბოლოს, სემინარზე თქვენ გექნებათ ამის გაკეთება ასევე.
>> ეს არის გავაკეთოთ სია app.
და თქვენ შეგიძლიათ შეხვიდეთ, შექმნა ანგარიშები, და დაამატოთ ამოცანები.
თქვენ შეგიძლიათ შექმნათ ანგარიში, როგორიცაა ასე.
და ახლა, როდესაც თქვენ ანგარიში, თქვენ შეგიძლიათ დაამატოთ ამოცანები.
მაგალითად, ერთ-ერთ ამოცანას I ალბათ უნდა წავიდეს შეარჩიო ჩემი სამრეცხაო.
და თუ თქვენ ამ საიტზე ამჟამად, თქვენ
ფაქტობრივად, რომ ეს ამოცანა თქვენს კომპიუტერში რეალურ დროში.
>> შემიძლია გაჩვენოთ სწრაფი დემო ამ გახსნით rozu-rabbit
სხვა tab იგივე URL.
და ჩვენ ვხედავთ, რომ იგივე მონაცემები მოდის.
ჩვენ შეგვიძლია ასევე აწარმოებს სხვადასხვა ბრაუზერში.
ამბობენ, რომ მე აწარმოებს Safari.
რომ გზა ჩვენ არ ხართ სისტემაში შესული.
ასე რომ, ჩვენ გვაქვს იგივე Meteor app, და კიდევ ის ტვირთავს,
ჩვენ დავინახავთ, იგივე მონაცემები ჩვენ გავაკეთეთ პირველი.
როგორც ხედავთ, მე არ ხართ შემოსული აქ.
და როდესაც აუდიტორიის ამოწმებს მონაცემებით, განახლებები ყველა ბრაუზერები
ერთდროულად.
ეს არის ერთ ერთი მართლა მაგარი ფუნქციები შესახებ Meteor.
თითქმის არ მუშაობა, თქვენ აქვს ცოცხალი განახლება app
რომ ცვლილებები ყველა თქვენი მოწყობილობების ერთდროულად.
>> თუ მე შემოწმება თოლიას აქ ჩემი გავაკეთოთ სია, გვექნება,
ჩემი სხვა Chrome ბრაუზერში, საქონლის შეამოწმეს off.
და ეს ხდება მომენტალურად.
ყველა უფლება.
ასე გამოიყურება Meteor მონტაჟი ახლაც მზად არის.
ახლა მოდით დავუბრუნდეთ todos app და აწარმოებს ამ ადგილობრივად.
>> თუ თქვენ გაქვთ Meteor პროექტი, თქვენ შეგიძლიათ უბრალოდ გაუშვით ბრძანება Meteor.
ერთხელ თქვენ ამის გაკეთება, Meteor გავაკეთებ მოსამზადებელი
რათა დავრწმუნდეთ, რომ ყველა თქვენი კოდი ქვითარი.
და მაშინ გეტყვით, რომ პროექტი მზად იქნება გაწერილი.
თქვენ ალბათ უნდა დაუშვას თქვენი firewall, თუ თქვენი კომპიუტერი ბლოკები.
>> ასე რომ, რა Meteor მეუბნებოდა ახლა ის არის, რომ ამ ნახვა,
ადგილობრივი ჩემი კომპიუტერი, მე ვხედავ რა ამ Meteor პროექტი.
გაითვალისწინეთ, რომ ახლა, ჩემი app არის არ არის ხელმისაწვდომი ინტერნეტში.
ჩვენ დაფარავს თუ როგორ, რათა თქვენი Meteor აპი ცოცხალი საიტზე ცოტა მოგვიანებით.
ამიტომ მე უბრალოდ აპირებს კოპირება ამ URL ახლა და წასვლას Google Chrome.
>> და ეს არის, რომ გავაკეთოთ, მიუთითეთ მაგალითზე.
თქვენ ხედავთ, რომ ისინი განხორციელდა რამდენიმე თვისებები აქ.
ჩვენ გვაქვს სხვადასხვა ჩანართების, ჩვენ აქვს იგივე ანგარიშზე თვისებები,
და ჩვენ შეგიძლიათ დაამატოთ ახალი სიები.
ახლა, ერთი ნამდვილად მაგარი თვისება Meteor
ის არის, რომ არა მხოლოდ შეიძლება ეს მუშაობა თქვენს ბრაუზერში,
მაგრამ ასევე შეგიძლიათ შექმნა შექმნილი iPhone და Android
apps მეშვეობით ინსტრუმენტი მოუწოდა PhoneGap.
>> ასე რომ გარკვეული პროექტები მოვა წინასწარ კონფიგურირებული გაშვებული
on iOS, როგორც ეს todos app.
ასე რომ ყველა მე უნდა გავაკეთოთ, რომ აწარმოებს iOS აკრიფოთ Meteor, აწარმოებს, ხოლო შემდეგ iOS.
და როდესაც მე, რომ Meteor მოამზადებს პაკეტი ერთხელ.
და შემდეგ, ერთხელ ის მზად არის, ის ყველაფერს ჩატვირთვა iOS simulator ჩემი ბრძანება.
შენიშვნა შეგიძლიათ მხოლოდ აწარმოებს iOS apps თუ თქვენ გაქვთ Mac კომპიუტერი.
თქვენ შეგიძლიათ აწარმოებს თქვენი apps on Android ყველა პლატფორმაზე მუშაობს.
>> ასე რომ, ახლა თქვენ ხედავთ, რომ ჩემი iPhone simulator გამოვიდა ჩემს ეკრანზე.
და რაღაც მომენტში, ეს თქვენ ჩატვირთვა app.
თუ ჩვენ უბრალოდ ცოტა პატარა ეტევა ეკრანზე,
ჩვენ ვხედავთ, რომ ჩვენ გვაქვს ჩვენი iPhone app.
და მხოლოდ ასე რომ ჩვენ არ დაბნეული, გადავდგათ
დარწმუნებული ვართ, იმავე ნახვა, ადგილობრივი მასპინძელი 3000.
>> ამიტომ სწორედ აქ არის მაგალითი საქართველოს Meteor app მაქვს,
todos app, გაშვებული როგორც ტელეფონი და ბრაუზერში.
და როდესაც მე შეცვალოთ პერსონალი ბრაუზერში,
იგი მაშინვე მიდის ტელეფონში.
და შემიძლია წაშლა რაღაც ტელეფონი, და ეს ცვლის ბრაუზერში.
>> ახლა, ჩვეულებრივ შექმნათ მშობლიურ ტელეფონი app for iOS და Android,
თქვენ უნდა იცოდეს, ან Java ან ობიექტური C. ტექნოლოგია Meteor მიზნებისათვის
საშუალებას JavaScript აწარმოებს როგორც თქვენი app ეწოდება PhoneGap.
რა თქვენი app არსებითად არის არის ვებ ბრაუზერი.
და Meteor ემსახურება ყველა სახიფათო ნაწილები ჩართული
შემოტანა, რომ ბრაუზერში თქვენი iPhone ან Android მოწყობილობა.
თქვენ ხედავთ, რომ ინტერფეისი არის გლუვი,
და ეს გამოიყურება და გრძნობს ძალიან ჰგავს შექმნილი app.
გაითვალისწინეთ, რომ თუ მე სახლში ეკრანზე ახლა, მე ასევე ხატი.
ეს არ არის ნახვა, როგორიცაა ნეტავ იპოვით Safari.
ეს არის საკუთარი ოთახი.
თქვენ შეგიძლიათ დააყენოთ და წაშალეთ ეს, თუ გსურთ.
>> ჩვენ შეგვიძლია მოკლედ გაჩვენებთ რა კოდი ამ სახის todos app ჰგავს.
თუ გადავხედავთ todos საქაღალდეში, თქვენ ნახავთ, არსებობს მრავალი ფოლდერები.
მაგრამ მეტი რა თქმა უნდა სემინარის ჩვენ გამოგიგზავნით
გავიგოთ, რა თითოეული ფოლდერი გამოიყენება.
მოდით წასვლას ტერმინალის ამიტომ ჩვენ შეგიძლიათ ნახოთ ფაილი ცოტა უკეთესი.
>> მე ვაპირებ დააჭირეთ Control C შეჩერება სერვერზე,
და ახლა მე უკან todos app.
მაქვს სხვადასხვა ფოლდერები აქ, ისევე, კლიენტის ფოლდერი, სერვერზე საქაღალდეში.
და პაპკების უბრალოდ ნიშნავს, რომ ყველაფერი კლიენტის ფოლდერი
იღებს დასაჯეს თქვენს ბრაუზერში.
ყველაფერი სერვერზე საქაღალდეში იღებს შესრულებული სერვერზე.
>> რა მინდა აღვნიშნო ის არის, რომ ის, რაც ჩვენ გვქონდა
როდესაც ჩვენ გვქონდა ჩვენი ტელეფონი გაშვებული და ჩვენს ბრაუზერში, ეს იყო კლიენტებს.
მაგრამ რა გაშვებული terminal, რომ სერვერზე.
გვაქვს სხვა ფოლდერები, როგორიცაა lib, რომელიც ბიბლიოთეკა კოდი,
როგორიცაა თქვენი შემწე ფუნქციები, რომელიც შეგიძლიათ
გამოყენება ორივე კლიენტის და სერვერის.
და მაშინ თქვენ გაქვთ გახსნილი ფოლდერი და რესურსები
ფოლდერი საჭირო მისაღებად თქვენი სურათები და სხვა CSS დატვირთული.
>> თუ თქვენ არ Meteor დაყენებული, ჩვენ გაგრძელდება სამეურვეო Meteor.
თქვენ შეგიძლიათ გადადით ამ URL, meteor.com/install,
მიიღოს ბრძანება ხაზი, რომ მე აჩვენა, რომ მოყვება Meteor.
ჩვენ გაიაროს პირველი რამდენიმე ნაბიჯები, რათა მიიღოთ უკეთესი
გრძნობს, თუ როგორ უნდა დააყენოთ Meteor.
>> მაგრამ პირველი, მე ვფიქრობ, რომ მნიშვნელოვანია, რომ ჩვენ განიხილავს ცოტა JavaScript.
გაჩვენოთ რამდენიმე მაგალითი, თუ როგორ ჩვენი C ცოდნა შეიძლება თარგმნა
რომ JavaScript, მე განთავსებულია რამდენიმე მაგალითი.
ისინი js დირექტორია.
ასე რომ, თუ სემინარებში საქაღალდე შეხედე, ფოლდერი სახელად js.
და აქ, ჩვენ გვაქვს რამდენიმე მაგალითი.
>> მოდით გახსენით პირველი მაგალითად და ვნახოთ, ძალიან სწრაფად.
რასაც ჩვენ ვხედავთ, თქვენი სტანდარტული hello world ბრძანება.
თქვენ შეამჩნევთ C, რომ თქვენ საკმაოდ ხაზები.
და როგორც CS50 სტუდენტები იცით, ჩვენ უნდა მთავარი ფუნქცია,
და ჩვენ უნდა შეიცავდეს სტანდარტული I / O ბიბლიოთეკა რათა დაუკავშირდეთ printf.
>> მოდით შევხედოთ, თუ როგორ JavaScript ადარებს.
მე ვაპირებ გახსნას ex1.js.
კომენტარი out არის ის, რაც C კოდი გამოიყურება ასე,
და ხაზის ქვემოთ ყველა თქვენ უნდა აწარმოებს Node.
თქვენ არ უნდა მთავარი ფუნქცია, თქვენ არ უნდა შეიცავდეს ნებისმიერი ფაილი,
და თქვენ არ უნდა დაბრუნდეს.
თქვენ უბრალოდ მოვუწოდებ CONSOLE.LOG.
ეს არის ეკვივალენტი თქვენი printf.
>> და ეს ხდება იგივე არგუმენტები printf აკეთებთ.
და იმისათვის, რომ აწარმოებს, ნაცვლად გაშვებული რათა ex1,
თქვენ უბრალოდ მოვუწოდებთ Node ex1.js.
წერთ Node და შემდეგ ფაილი, და იგი იღებს აწარმოებს.
ეს არ არის შედგენილი.
JavaScript არის ინტერპრეტირებული ენა.
ასე რომ არ უნდა იყოს შედგენილი ადრე ის აწარმოებს.
თუ მინდოდა აწარმოებს ex1.c, მე უნდა მიიღოს იგი, პირველ რიგში,
და მაშინ შემიძლია აწარმოებს შესრულებადი მიიღოს იგივე გამომავალი.
>> მოდით სწრაფად ფარავს რამდენიმე სხვა JavaScript ცნებები.
მოდით შევხედოთ მაგალითად ორი.
In ex2.js, in ex2.c, ჩვენ შეგვიძლია , რომ ჩვენ გვაქვს რამდენიმე კოდი.
მიადევნე თვალი სწრაფად წასვლა უკეთესი ტექსტური რედაქტორი
რომ გამოჩნდება ამ ახალი ხაზების ცოტა უკეთესი.
ყველა უფლება.
აქ ჩვენ გვაქვს მაგალითად 2.c.
აქ ჩვენ გვაქვს სხვადასხვა სახის რომ ჩვენ დაბეჭდვისას.
და როგორც ვიცით, printf იღებს სხვადასხვა პროცენტი არგუმენტები
წვდომის სხვადასხვა ცალი მონაცემები.
თუ ჩვენ გვინდა ბეჭდვა სიმებიანი, მოვუწოდებთ% s.
თუ ჩვენ გვინდა, რომ მცურავი პუნქტი, ჩვენ მოუწოდა% ვ.
და არ არსებობს მარტივი გზა, რათა დაუკავშირდეთ ლოგიკური მისი ჭეშმარიტი ან მცდარი მნიშვნელობა.
მაგრამ თუ თქვენ იყენებთ% d, შეგიძლიათ მიიღოთ 0 ან 1 ცრუ და ჭეშმარიტი.
>> JavaScript არის ცოტა გავალამაზოთ ჩვენთვის.
JavaScript, მოდით შევხედოთ რამდენიმე განსხვავებები გვაქვს ეს ფაილი.
პირველი, თქვენ შეამჩნევთ, რომ C გვაქვს ინიციალიზაცია ყველა ცვლადს ტიპის.
S არის char ვარსკვლავი.
ეს ტექსტი, და ეს არ შეიძლება იყოს რაიმე სხვა ტიპის.
N არის float.
B არის bool.
>> მაგრამ JavaScript, არსებობს დინამიური ტიპის.
ეს იმას ნიშნავს, რომ თქვენ არ უნდა გითხრათ, JavaScript
რა სახის თქვენი ცვლადები იქნება.
უბრალოდ, ვამბობთ var ცვლადი, სახელი ცვლადი, და შემდეგ მისი ღირებულება.
ასე var შეიძლება არაფერი ნამდვილად.
ეს შეიძლება იყოს სიმებიანი.
ეს შეიძლება იყოს მცურავი პუნქტიანი ნომერი.
ეს შეიძლება იყოს ხასიათი.
ეს შეიძლება იყოს ლოგიკური.
და console log მუშაობს ცოტა განსხვავებულად.
თუ გსურთ ბეჭდვა ნომერი, რეკავთ% d.
მაგრამ ყველაზე ღირებულებები შეიძლება იყოს დაბეჭდილი როგორც სიმები მხოლოდ ჯარიმა.
>> მოდით აწარმოებს ამ Node ვნახოთ, რა მოხდება.
მე მოვუწოდებ Node ex2.js, და მივიღებთ printf
ღირებულებები CS50, N, როგორც მცურავი პუნქტიანი ნომერი,
და მაშინ B, როგორც ლოგიკური მოაქცია სიმებიანი ჭეშმარიტი.
რაც შეეხება, თუ ჩვენ მივიღეთ მაგალითად 2.c?
ასევე, ჩვენ ჯერ კიდევ აქვს გარკვეული უფრო annoyances printf.
გაითვალისწინეთ, რომ მცურავი წერტილი ნომერი უნდა იყოს დაფორმატებული სწორად,
და რომ ლოგიკური არ შეიძლება, უბრალოდ უნდა აისახოს, როგორც ჭეშმარიტი ან მცდარი.
ყველა უფლება.
ახლა მოდით შევხედოთ მაგალითად სამი.
მაგალითად სამი, ჩვენ ვაჩვენებთ როგორ გამოიყენოს ამისთვის loop.
ფაქტობრივად, ეს არის ძალიან მარტივი.
ერთი ლამაზი რამ JavaScript არის ის, რომ C დაფუძნებული.
ეს ნიშნავს, რომ ბევრი თქვენი კოდი გამოიყურება ძალიან ჰგავს
და ძალიან ბევრი ერთი და იგივე.
ამისთვის მარყუჟის, ერთადერთი, რომ მართლაც შეიცვალა აქ
ნაცვლად int i, ჩვენ გვაქვს var i.
ჩვენ ჯერ კიდევ შეგვიძლია მივანიჭოთ მას ვაფასებთ ნულოვანი, შეამოწმოს, რომ ეს ხუთზე ნაკლები,
და იყოს იგი ერთ-ერთი ერთად ++ ოპერატორი.
ჩვენ მოვუწოდებთ CONSOLE.LOG on i, და რომ ბეჭდვა us რიგი თითოეული ხაზი.
მოდით გაუშვით ძალიან სწრაფად ვნახოთ რა ეს შედეგები.
მივიღებთ ახალი ნომერი, თითოეული ხაზი.
კიდევ ერთი რამ მინდა გთხოვოთ, შეამჩნია ერთად CONSOLE.LOG
არის, რომ თქვენ არ უნდა დაწეროს წარმატებული n ახალი ხაზი.
CONSOLE.LOG ბეჭდვა ყველაფერი საკუთარი ხაზი.
ეს არის ლამაზი ფუნქცია რომ JavaScript გვაძლევს.
>> ახლა მოდით გახსენით მაგალითად ოთხი.
მაგალითად, ოთხი, პირველი C, ჩვენ მოუწოდებენ რამდენიმე ფუნქციები.
გაითვალისწინეთ, რომ ჩვენ უნდა განაცხადოს ფუნქციები ადრე ჩვენ ვიყენებთ მათ მთავარ.
თუ ჩვენ გვქონდა მთავარი პირველი და შემდეგ დავამატოთ და შემდეგ მაღალი, მიიღოს,
clang, ან GCC იქნებოდა გვაძლევს შეცდომა ამბობდა
ის, რომ არ იცის, რა მაღალია.
ეს არ ვიცი რა add არის.
ასე რომ, C, თქვენ უნდა იყოს picky შესახებ იმისათვის, რომელშიც თქვენ თქვენი ფუნქციები.
>> მოდით შევხედოთ, თუ როგორ შეგიძლიათ ამისათვის JavaScript.
ჩვენ გვაქვს სხვადასხვა ფაილები იმიტომ, რომ იქ არსებობს რამდენიმე სხვადასხვა გზა ამის გაკეთება.
ერთი გზა არის საკმაოდ ბევრი პირდაპირი თარგმანი.
რადგან ფუნქციების C დაბრუნების ტიპის და JavaScript
ნამდვილად არ ვიცი და არც მაინტერესებს შესახებ, თუ რა ტიპის დაბრუნებას,
თქვენ არ წერენ ტიპის.
ამის ნაცვლად, თქვენ უბრალოდ უნდა წერენ ფუნქცია,
და ყველაფერი საკმაოდ ბევრად იგივე, როგორც ადრე.
>> როდესაც თქვენ გაქვთ ცვლადი, ისევე როგორც რჩეულებში ჩვენ უბრალოდ უნდა დაწეროს x და y.
ჩვენ არ უნდა ვთქვათ, x არის int.
ჩვენ არ უნდა ვთქვათ y int.
ჩვენ დაბრუნებას იგივე სინტაქსი.
მაღალი ვაცხადებთ, იგი ფუნქციონირებს ნაცვლად ბათილად.
გაითვალისწინეთ, რომ თუ არა მისი ბათილად ან არასამთავრობო ბათილად,
მაინც ყველა იგივე ფუნქცია.
ჩვენ, უბრალოდ, არ დააყენა არაფერი ფრჩხილებში,
და ეს ძალიან ჰგავს C კოდი.
და ქვემოთ, ჩვენ შეგვიძლია ეძახით ქვემოთ.
>> თუ დავაკვირდებით მაგალითად 4b, შევნიშნავთ რომ მე შეიცვალა რამდენიმე რამ.
ერთადერთი, რაც მე შეიცვალა მართლაც, თუმცა არის მიზნით.
ჩვენ გვაქვს იგივე ფუნქციები, მაგრამ ახლა ისინი
შემდეგ განაცხადა, რომ ისინი გამოიყენება CONSOLE.LOG და მაღალი ხაზები 18, 19.
თუ ეს C, რათა რომ ჩააგდოს შეცდომა.
აქ, ეს მუშაობს მხოლოდ ჯარიმა.
და მე შემიძლია ეს თქვენ მიერ მოუწოდებდა Node on 4b მაგალითად.
>> სხვა გზა ჩვენ შეგვიძლია მოვუწოდებთ ფუნქციები არის გადარჩენის ფუნქციები როგორც ცვლადი.
როგორც ვთქვი, ცვლადი შეიძლება რაიმე ტიპის.
ერთი ტიპის ცვლადი შეიძლება ჰქონდეს ფუნქცია.
ასე რომ, თუ გადავხედავთ, მაგალითად, 4c, რაც მე შეიცვალა
აქ არის var რჩეულებში ნაცვლად ფუნქცია add.
და ახლა რჩეულებში ტოლია ფუნქცია.
ეს ფუნქცია აქ არის ანონიმური.
მას არ აქვს სახელი, ისე უბრალოდ ფუნქცია და შემდეგ ფრჩხილებში.
სინტაქსი მას შემდეგ, რაც არ იცვლება, მაგრამ თქვენ
უნდა გვახსოვდეს, რომ თქვენ გაქვთ ცვლადი, რომ თქვენ
შენახვის ფუნქცია add და ცვლადი, რომ თქვენ შენახვა მაღალი.
>> იმის გამო, რომ დაამატოთ და მაღალი ახლა ცვლადები და არა ფუნქციები, რაღაც იცვლება.
ეს არის საერთო bug მე ვხედავ ბევრი ადამიანი JavaScripts,
და რაღაც უნდა გვახსოვდეს.
როდესაც მე აწარმოებს ამ, ვნახოთ, რა მოხდება.
მე შეცდომა.
ის ამბობდა undefined ამ ეტაპზე.
ამიტომ ვამბობ, რომ ეს არ ვიცი, რა რჩეულებში არის.
>> რადგან ახლა რჩეულებში არ არის ფუნქცია, დაამატეთ ცვლადი.
და თქვენ არ მოგვივლინა რჩეულებში მნიშვნელობა ჯერ კიდევ მაშინ, როდესაც გამოიყენება იგი.
რომ მოაქვს მაგალითად 4d, სადაც თუ გსურთ გამოიყენოთ ცვლადები ფუნქციები,
თქვენ უბრალოდ უნდა დავრწმუნდეთ, რომ ისინი მიიღოს ღირებულება, სანამ ისინი გამოიყენება.
>> მოდით გადაადგილება ხუთ შემდეგ.
აქ, ჩვენ ვსაუბრობთ structs in C. In C, structs
აქვს ამ ფიქსირებული სტრუქტურა მათ იმიტომ, რომ თქვენ უნდა გამოვაცხადოთ
სანამ გამოიყენოს იგი, და თქვენ ამბობთ, რომ მე სტუდენტი,
და ყველა სტუდენტს აქვს ზუსტად ერთი სახელი, ერთი წლის განმავლობაში, ერთი სქესის.
მას აქვს ყველა მათგანი.
ეს არ შეიძლება ჰქონდეს რაიმე სხვა ფასეულობა, და ისინი უნდა იყოს კონკრეტული ტიპის.
>> მაშინ ჩვენ შეგვიძლია ინიციალიზაცია struct ამ ლამაზი სინტაქსი
რადგან იცის მიზნით.
ასე რომ იცის, რომ როჯერ არის სახელი.
იგი დარწმუნებულია, რომ 2016 არის წელს და M გენდერული
იმიტომ, რომ ჩვენ განუცხადა იგი ამ სიაში struct სტუდენტი.
და შემდეგ შეგიძლიათ ამობეჭდოთ ის, წვდომის s.name.
ვნახოთ, თუ როგორ ჩვენ გვინდა გარდაქმნას, რომ JavaScript.
გაითვალისწინეთ, რომ ეს არის ცვლადი, და არ არსებობს ტიპის.
ეს მხოლოდ var ერთხელ.
იმის გამო, რომ არ აქვს მნიშვნელობა, თუ ტიპი ცვლადი მაჩვენებელი,
ეს struct, ან არაფერი.
ჩვენ გვაქვს ოდნავ განსხვავებული სინტაქსით.
ეს სინტაქსი არის ობიექტი სინტაქსი.
>> თქვენ შეიძლება არ მინახავს ეს JSON.
JSON რეალურად დგას JavaScript Object ნოტაცია.
ეს არის, თუ როგორ განსაზღვრავს ობიექტების JavaScript.
ჩვენ გვაქვს გასაღები, რომელიც ღირებულება, როგორიცაა სახელი.
და ჩვენ მას აფასებს on მეორე მხარეს მსხვილი ნაწლავის.
და ერთი რამ უნდა გვახსოვდეს არის ის, რომ თქვენ არ უნდა ჰქონდეს სახელი და წელიწადში
და სქესის ობიექტი.
ობიექტი შეიძლება არ გააჩნია ღირებულებები.
მას შეუძლია, როგორც ბევრი როგორც გსურთ.
>> ჩვენ შეგვიძლია გამოვიყენოთ ამ ობიექტების მხოლოდ იგივე გზა ჩვენ ვიყენებთ struct, s.name.
ჩვენ შეგვიძლია გაუშვით ძალიან სწრაფად ამით კვანძის მაგალითად 5.c.
ჩვენ არ შეგვიძლია რეალურად აწარმოებს C ფაილი Node.
ეს არ ვიცი რა არის C.
ეს მხოლოდ იცის, JavaScript.
როდესაც ჩვენ აწარმოებს ex5.js, მივიღებთ ღირებულება, რომელიც ჩვენ გვგონია.
>> მოდით გადაადგილება მაგალითად ექვსი.
აქ მე უბრალოდ მინდა გაიგო ცოტა ცოტა მეტი JavaScript კოლექტორები
იმიტომ, რომ ისინი ცოტა განსხვავებული, ვიდრე თქვენ
გამოიყენება in C. კოლექტორები არის ნოტები, არა ფრჩხილები, C,
ერთად Curly braces, მაგრამ ფრჩხილებში.
თქვენ შეგიძლიათ ცარიელი მასივი, როგორიცაა arr ხაზის ოთხი.
თქვენ შეგიძლიათ კოლექტორები მრავალჯერადი ღირებულებებს.
და შეღწევის მხოლოდ იგივე გზა C.
>> მდე ხაზის შვიდი, ყველაფერი როგორც ჩანს, საკმაოდ მარტივია.
ერთი უმნიშვნელო განსხვავება არის აქ line 10.
გზა თქვენ სიგრძე მასივი მხოლოდ დარეკვით .length.
მასივი შეიძლება რეალურად იყოს განიხილება, როგორც ობიექტი,
და ეს ობიექტი სიგრძე ქონება რომ თქვენ მოვუწოდებთ მისაღებად სიგრძის იყო.
გაითვალისწინეთ, რომ ეს არის სხვადასხვა in C რადგან C თქვენ
უნდა იცოდეს სიგრძე თქვენი ობიექტი ვადამდე.
>> ასე რომ კიდევ ერთი ლამაზი რამ მასივები არის, რომ თქვენ შეიძლება ჰქონდეს სხვადასხვა სახის.
თუ თქვენ გაქვთ მასივი, C, არსებობს კოლექტორები კონკრეტული ღირებულება,
ან struct მაჩვენებელი ან მოძრავი ან [INAUDIBLE].
აქ, თქვენ სხვადასხვა ფასეულობები გვაქვს.
მე პირველად მქონდა მცურავი პუნქტიანი ნომერი, მაშინ ლოგიკური, მაშინ კიდევ ერთი რიცხვი.
და რეალურად, ისინი შეიძლება შეიცვალოს ტიპის ძალიან.
შევხედოთ ხაზი 16.
Array ორი იცვლება მიმდინარეობს ნომერი, რიცხვი, სიმებიანი.
>> კიდევ ერთი ლამაზი რამ მასივების აქ ხაზი 19, მათ აქვთ უსაზღვრო ზომა.
შეგიძლიათ უბრალოდ მინდა მეასედ ელემენტს უნდა იყოს string legit.
და ეს არ ჩანს, რომ გრძნობა, რადგან მასივი მხოლოდ
აქვს ფართი სამი ელემენტები, ასე რომ, ბოლოს, უნდა იყოს ორი.
მაგრამ როდესაც თქვენ ამის გაკეთება, მოდით ვნახოთ, რა მასივი სამი ხდება.
ჩვენ მივრბოდით სწრაფად კვანძის მაგალითად six.js.
ჩვენ ეს მართლაც დიდი მასივი, და რა ხდება
არის, რომ ჩვენ გვაქვს პირველი რამდენიმე ელემენტებს და შემდეგ bunch of ბლანკები
სანამ არ მივიღებთ ჩვენი სიმებიანი.
JavaScript ავსებს მასივი, როგორც ეს საჭიროა.
>> მოდით საბოლოოდ წასვლა ჩვენი ბოლო მაგალითია.
აქ ჩვენ გვაქვს სია სხვადასხვა სტუდენტებს.
მინდა გაიგო ცოტა ცოტა რამოდენიმე ლამაზი ასპექტები
ამისთვის მარყუჟების JavaScript.
In C, მარყუჟების სახის შეზღუდული.
მათ აქვთ ფიქსირებული სტრუქტურა, სადაც თქვენ ცვლადი, თქვენ გაქვთ პირობით,
და მაშინ, რომ რამე ბოლოს ციკლი.
და რა თქმა უნდა ეს სამუშაოები JavaScript, როგორც დავინახეთ, წინა მაგალითები.
მაგრამ ჩვენ ასევე გვაქვს გავალამაზოთ გზა ამით JavaScript.
ეს ეწოდება foreach loop.
>> უკაცრავად, მოდით დავუბრუნდეთ რომ მაგალითად შვიდი აქ.
შეიძლება ითქვას, სექცია არის სიაში.
ასე რომ მომეცი ყველა i ან ყველა მაჩვენებელი, რომ სიაში.
შემდეგ ჩვენ შეგვიძლია მივიღოთ სტუდენტი მხოლოდ მოუწოდებენ მონაკვეთზე i.
ასე რომ ყველა კოდი შექმნის i ნულის ტოლია და მიღების დარწმუნებული ვარ i
ნაკლებია, ვიდრე სიგრძის და დასძინა ერთი i ყოველ ჯერზე, რომ
ზრუნვა თქვენ საკმაოდ ლამაზად ამ foreach loop.
>> არა მხოლოდ არ foreach მარყუჟების მუშაობა სიები ან მასივები,
ისინი ასევე მუშაობენ ობიექტები, რომელიც ასევე ლამაზი.
თქვენ შეგიძლიათ მიიღოთ სახელი ყველა ქონების უბრალოდ აღების
ლექსიკონი ან ობიექტი, როგორიცაა სტუდენტი, და მხოლოდ მაშინ განაცხადა, რომ მომეცი ყველა გასაღები.
გასაღები იქნება ეს თვისებები, სახელი ან სახლი.
ასე რომ, რა მოხდება აქ ის არის, რომ ჩვენ ამობეჭდოთ პირველი სახელი და შემდეგ
სახლში ყველა სტუდენტი.
>> შემიძლია აწარმოებს ამ Node მართლაც სწრაფად გაჩვენოთ.
მივიღებთ პირველი C style for loop, სადაც მივიღებთ ყველა ობიექტი იბეჭდება out.
და მაშინ ჩვენ გვაქვს JavaScript სტილი, სადაც შეგიძლიათ მხოლოდ
ამობეჭდოთ ყველა გასაღები და ვაფასებთ ინდივიდუალურად.
>> ყველა უფლება.
ახლა, ჩვენ დაფარული Node.js, მე ვფიქრობ, ჩვენ მზად ვართ დავიწყოთ Meteor.
როგორც ვთქვი, Meteor გააკეთა დიდი სამუშაო წერის გარკვეული მზა მაგალითები
რომ თქვენ შეგიძლიათ შეისწავლონ მეშვეობით ამ tutorial ან სემინარში საქაღალდეში.
მაგრამ აქ მინდა დაიწყოს უფრო ნულიდან.
>> მოდით შევქმნათ მარტივი უნდა გააკეთოს განაცხადი.
ეს არის ერთგვარი ბაზაზე, რა უნდა გააკეთოს განაცხადი მე აჩვენა თქვენ ადრე არის.
ამ tutorial, თქვენ ნახავთ, რომ არსებობს
ბრძანება Meteor შექმნა შექმნა ახალი Meteor პროექტი.
თქვენ უნდა დაუკავშირდეთ ამ მიზნით, აწარმოებს Meteor პროექტები, რადგან ის
მიიღებს ბრძანებები შექმნათ Meteor
ფაილი საჭირო თქვენი პროექტის.
>> თუ წასვლას ტერმინალში, ჩვენ შეგვიძლია წასვლას ფოლდერში სახელად ერთი ნაბიჯი.
და ნაბიჯი ერთი შეესაბამება პირველი ნაბიჯი სამეურვეო.
განაცხადის არსებობს ფოლდერები, ნაბიჯი ერთი, ნაბიჯი ორი, ყველა გზა ხუთ.
და თითოეული შეესაბამება რომ ნაბიჯი ამ tutorial.
მე ვაპირებ გახსნა ჩემი ტექსტური რედაქტორი აქ
ასე რომ, ჩვენ ვხედავთ, ცოტა რა შეიქმნა.
ჩვენ შევამჩნევთ, რომ ოთხი ძირითადი ნაწილისაგან.
არსებობს Meteor დირექტორია, .meteor.
და რომ თქვენ, როგორც წესი, არ უნდა შეეხოთ.
Meteor ზრუნავს რომ საქაღალდეში, და ეს მხოლოდ
დარწმუნებული ვარ, რომ თქვენი პროექტის იმუშავებს სწორად.
>> ჩვენ ასევე გვაქვს სამი ფაილი, HTML ფაილი, JavaScript ფაილი, და CSS ფაილი.
მოდით დავიწყოთ HTML ფაილი.
ერთი შეხედვით, ეს გამოიყურება როგორც ნორმალური HTML დოკუმენტი.
მაგრამ შეამჩნია, რომ არსებობს რამდენიმე განსხვავებები.
ერთი, ეს არ არის რეალურად სრული HTML დოკუმენტი.
ჩვენ დაკარგული HTML tags.
ეს არის ნორმალური.
მეტეორის, თქვენ არ ელოდებიან შექმნა ამ HTML tags.
რომ კეთდება თქვენთვის.
გსურთ begin-- თუ გვინდა შევქმნათ საიტი,
თქვენ უბრალოდ უნდა დაიწყოს ერთად ხელმძღვანელი tag,
განმარტავენ, რომ, და შემდეგ განსაზღვროს ორგანოს აქვს.
>> მაგრამ თუ თქვენ შეამჩნევთ ამ HTML ფაილი, ჩვენ გვაქვს ახალი აქვს.
ჩვენ გვაქვს თარგი აქვს.
ეს არ არის ნორმალური HTML.
ეს არის სპეციალური ვერსია HTML რომ Meteor რაც ხელმისაწვდომი.
ეს ე.წ. სივრცეში ბარი.
თქვენ შეგიძლიათ განსაზღვროთ თარგები, როგორც პატარა, მოდულები, სახის, როგორიცაა დამხმარე ფუნქციები,
თქვენს C ან JavaScript კოდი.
ეს თარგი გვინდა აქვს სახელი უწოდა ამოცანა.
და თქვენ ხედავთ, სწორედ აქ on line 13 რომ შეგიძლიათ დარეკოთ ეს თარგები.
და რა Meteor ყველაფერს გააკეთებს მხოლოდ შეავსოთ ამ ამოცანებს თქვენ.
>> კიდევ ერთი რამ თქვენ შეამჩნევთ არის ცოტა განსხვავებული არის ეს თითოეული ფუნქცია.
თითოეულ მიიღებს ცვლადი ამოცანები და სახის გაიაროს ეს
რომ foreach loop ჩვენ ვნახე მაგალითად შვიდი.
ეს ყველას შეუძლია ლექსიკონი ან სია, ობიექტის ან სია,
და ეს კიდე უბრალოდ გავლა ყველა ღირებულებებს, როგორიცაა foreach loop აკეთებთ.
ასე რომ, თუ ჩვენ გვაქვს რამოდენიმე ამოცანები, ამ მოვუწოდებთ template თითოეული ამოცანა.
>> მოდით აწარმოებს Meteor პროექტი უბრალოდ, რომ ეს მოხდება.
მე აწარმოებს Meteor პროექტი უბრალოდ Meteor ან Meteor აწარმოებს.
და ახლა Meteor უბრალოდ უნდა სწრაფად მოამზადოს პროექტის,
დაიწყება მონაცემთა ბაზა, როგორც საჭიროა, და შემდეგ დაპოსტოთ ოთახი ადგილობრივად.
ჩვენ შეგვიძლია წავიდეთ ჩვენს ბრაუზერში ახლა.
და ჩვენ ვხედავთ, რომ ჩვენ აქვს ძალიან მარტივი app.
ასე რომ, რა ვნახეთ გამოჩნდა იყო, ფაქტობრივად, ერთი ნაბიჯი, ნაბიჯი ერთი ფაილი.
>> მოდით გადაადგილება დახევას ორი მხოლოდ იმიტომ, მე ვფიქრობ, რომ ამავე მიზანს ემსახურება.
მე უბრალოდ აპირებს შეცვალოს ნაბიჯ ორი დირექტორია
და აწარმოებს Meteor ერთხელ ასე ვხედავთ თარგი ჩვენ უბრალოდ მუშაობდა.
დიახ, კითხვაზე?
>> აუდიტორია: თუ ჩვენ ვიღებთ ნებართვას უარყო, ისაა, რომ რა არის ეს
მოუწოდა, რომ?
ROGER ZURAWICKI: თუ თქვენ გაშვებული Meteor პერსპექტივაში,
და თქვენ გაქვთ უარყო, ზოგიერთი თქვენი ფაილი
შესაძლოა, არ აქვს უფლება, ნებართვის კომპლექტი.
ასე რომ თქვენ უნდა შეამოწმოთ სადაც ნებართვების off.
ისინი შეიძლება იყოს off in თქვენი Meteor პროექტი,
ან ისინი შეიძლება ში Meteor ფაილი თავს.
>> აუდიტორია: თუ მე გადმოწერილი ეს მხოლოდ ახლა თქვენი GitHub, მაშინ რა უნდა გავაკეთო
[INAUDIBLE]?
>> ROGER ZURAWICKI: თუ გსურთ დარწმუნდით, რომ თქვენ შეგიძლიათ თქვათ ეს,
არსებობს ბრძანება შეგიძლიათ აწარმოებს.
ნება მომეცით სწრაფად დაწერა ის ისე სხვა ადამიანები დანახვა.
მე ვაპირებ გახსნას ახალი tab აქ და წასვლას ჩემი სემინარი საქაღალდეში.
Chmod არის ბრძანება შეცვლის ნებართვა,
და შეიძლება ითქვას r for ამის გაკეთება რეკურსიული ყველა ფაილი.
და ნებართვების, შეგიძლიათ სცადოთ 0755 დარწმუნდით, რომ თქვენ გაქვთ სრული დაშვება,
და ყველას აქვს უფლება წაიკითხოს.
და თუ თქვენ მხოლოდ აწარმოებს ეს ბრძანება, ეს გავაკეთებ
დარწმუნებული ნებართვების არიან შემოწმება მთელი დირექტორია.
გაშვებული ls-l შეუძლია გიჩვენოთ ნებართვების უფრო დეტალურად.
ეს გამოიყურება OK.
>> რაც ყველაზე მნიშვნელოვანია, რომ თქვენ გაქვთ სამივე
rwx ყველა ფაილი სემინარის დირექტორია.
იცოდით, რომ ამ პრობლემის მოსაგვარებლად?
>> აუდიტორია: იგი ამბობს დაკარგული operant [INAUDIBLE].
[INAUDIBLE]
ROGER ZURAWICKI თქვენ უნდა დავრწმუნდეთ, რომ თქვენ
აქვს dot დასასრულს თქვენი ბრძანება.
აუდიტორია: [INAUDIBLE].
ROGER ZURAWICKI ყველა უფლება.
მოდით, სწრაფად დაბრუნდეს ადგილობრივი მასპინძელი, app გვაქვს.
და დაინახავთ, რომ ჩვენ გვაქვს რამდენიმე ამოცანები აქ, როგორც მოსალოდნელი იყო.
ჩვენ გვაქვს bunch of CSS, რომელიც თქვენ არ გჭირდებათ ფიქრი.
Meteor tutorial უბრალოდ აძლევს, ეს თქვენ
იმისათვის, რომ თქვენი გავაკეთოთ სია სახე ცოტა გავალამაზოთ, ვიდრე უბრალო HTML.
და ჩვენ გვაქვს JavaScript ფაილი, რომელიც მე წასვლას უფრო დეტალურად ცოტა მოგვიანებით,
მაგრამ ეს მხოლოდ უზრუნველყოფს ამ ამოცანებს.
ეს არის ამოცანა ერთი.
ეს არის ამოცანა ორი.
ეს არის ამოცანა სამ.
ასე რომ, ეს მონაცემები Meteor ის მისაღებად.
>> ერთი მაგარი რამ Meteor არის რომ ცვლილებები შეიძლება მოხდეს ავტომატურად.
თუ მინდოდა, რომ შეიცვალოს დასახელება პირველი ამოცანა,
ასე რომ, ეს არ ნიშნავს ამოცანა ერთი, და მე გადაარჩენს,
მაშინ, როდესაც მე წასვლა ვებ თქვენ ბრაუზერში ამოცნობა,
და ეს ავტომატურად ამბობს ეს არ არის ამოცანა ერთი.
შეგიძლიათ გააკეთოთ იგივე ნებისმიერი ეს ფაილი.
ცვლილება, ნაცვლად უნდა გააკეთოს სია, მე ეს ჩემი გავაკეთოთ სია.
>> და ერთი რამ თქვენ უბრალოდ შენიშნა, რომ მე კი არ უნდა ამოცნობა.
იდეა გამაგრილებელი სახის მოგვარდება თქვენთვის Meteor.
როდესაც იგი ცნობს ფაილის ცვლილებები, ის ჩატვირთვა ცვლილებების თქვენ.
ეს მუშაობს ყველა ფაილი, თუ არა ეს HTML, CSS, ან JavaScript.
რათა ნახოთ თუ რა ამ app გამოიყურება როგორც გარეშე CSS, შემიძლია ამოიღონ ეს ყველაფერი.
და როდესაც ის Reloaded, თქვენ ახლა აქვს არა როგორც ლამაზი, ლამაზი გავაკეთოთ სია.
მოდით ვთქვათ, რომ შინაარსი უკან.
და აუცილებლად საკმარისი, ამხნევებს და ჩვენი ცენტრის უკან.
დიდი.
>> ახლა ჩვენ შეგვიძლია გადაადგილება ერთად tutorial.
მოდით ვისაუბროთ ნაბიჯი ორი, თარგები.
ეს არის ის, რაც ჩვენ ვნახეთ სხვადასხვა ამოცანები.
Meteor აგიხსნით, თუ რა თარგები და როგორ ლოგიკა მუშაობს.
მაგრამ მოდით შევჩერდეთ კოდი თუ ჩვენ შეგვიძლია აზრი გარეთ.
>> ძალიან მარტივი პროგრამა, როგორიცაა, რაც ჩვენ გვაქვს მარტივი
ამის გაკეთება, ერთი ნაბიჯი, ნაბიჯი ორი, ნაბიჯი სამი ნაბიჯი ოთხი, ნაბიჯი ხუთ,
ჩვენ არ გვაქვს რაიმე ფოლდერები.
ჩვენ არ გვაქვს სერვერზე ფოლდერი ვთქვი.
ჩვენ არ გვაქვს კლიენტს საქაღალდეში, რომელიც აღინიშნა.
ასე Meteor მიიღებს ყველა ფაილი.
ეს კიდე გაუშვით ორივე კლიენტს, ორივე სერვერზე.
>> და თუ გსურთ ნაწილების თქვენი JavaScript კოდი აწარმოებს მხოლოდ კლიენტს,
მათ უნდა დავრწმუნდეთ, რომ თქვენ გაქვთ თუ განაცხადი, სახის მოსწონს რა
ჩვენ გვაქვს ჩვენი JavaScript ფაილი აქ.
ასე Meteor, მხოლოდ იმ შემთხვევაში თუ ის კლიენტს, მაშინ მე
გვინდა, რომ განსაზღვროს თარგი დამხმარე მოუწოდა ამოცანები.
რა ეს კოდი მართლაც არ არის, იგი აცხადებს, რომ იქ
ობიექტი მოუწოდა template რომ Meteor უზრუნველყოფს.
და ჩვენ ვაპირებთ, რომ დაამატოთ დამხმარე.
დამხმარე ამ ამოცანებს, ამ რამ, როგორიცაა ამოცანები.
>> დაინახავთ, რომ თუ ჩვენ დაბრუნდეს HTML ფაილი, ჩვენ მოუწოდა თითოეულ ამოცანები.
ამოცანები არ არის განსაზღვრული HTML.
ეს განსაზღვრულია JavaScript.
და Meteor უნდა იცოდეს, თუ რა ამოცანების არის როდესაც ჩვენ წასვლას JavaScript აქ.
ამოცანები არის ამ დამხმარე.
დამხმარე, შეგიძლიათ წარმოიდგინოთ, როგორც შაბლონი ცვლადი.
და რას ამოცანები გავაკეთოთ?
ასევე, ის დააბრუნებს სიაში ღირებულებებს.
იმიტომ, რომ ეს არის სია, ჩვენ შეგვიძლია მოვუწოდებთ თითოეულ იგი.
სწორედ ამიტომ ჩვენ მოვუწოდებთ თითოეულ ამოცანები.
და ახლა ჩვენ გვაქვს ამოცანა.
>> რას ამოცანა გავაკეთოთ?
ისე, რომ მას აქვს ამ arrow აქ მას შემდეგ Curly braces.
ეს ნიშნავს, რომ ამოცანა არის შაბლონი.
ეს არ არის დამხმარე, მსგავსი იმისა, რაც ჩვენ უბრალოდ დაინახა.
ეს თარგი ჩვენ განსაზღვრული.
და სადაც ჩვენ განსაზღვრა?
ჩვენ განსაზღვრული ქვემოთ უფლება აქ.
>> ყველა ეს თარგი არ არის, გამოიტანოს სიის ელემენტი, და მოუწოდებს ტექსტი.
ახლა, ტექსტი, როგორც ჩანს, დამხმარე, მაგრამ მე გაჩვენებთ
რომ ეს არის რეალურად მაინც მონაცემთა წევრი ამოცანები.
როდესაც თქვენ მოვუწოდებთ თითოეულ, ის გადადის მონაცემები სტრუქტურა ცოტა.
როგორიცაა foreach loop, ახლა უბრალოდ გამოიყურება პირველი ელემენტს ჩვენი ობიექტი.
ჩვენ ვხედავთ, რომ ტექსტი არის აქ განისაზღვრება ჩვენი ობიექტი.
ასე Meteor ჭკვიანი ვიცი, რომ ჩვენ ვსაუბრობთ ამ ტექსტს,
არ დამხმარე მოუწოდა ტექსტი.
ეს მხოლოდ იღებს ღირებულება ამ ტექსტი და მონიტორები, როგორც HTML,
და ეს როგორ მონაცემები მიდის საწყისი JavaScript რათა HTML.
>> მოძრავი თუმცა, ამ მაგალითში ჩვენ რთული კოდირებული იმ ღირებულებებს.
Meteor აკეთებს ორი ნამდვილად ლამაზი რამ ჩვენთვის.
გარდა ამისა, ცოცხალი განახლება, რომელიც ჩვენ აჩვენა, მას ასევე მართავს ჩვენს მონაცემთა ბაზაში.
თუ მოუხდა მუშაობა PHP, თქვენ ჰქონდა კონფიგურაციის phpMyAdmin.
თქვენ უნდა დავრწმუნდეთ, თქვენი მაგიდები იყო ყველა ქვითარი.
თქვენ უნდა გავაკეთოთ ბევრი მუშაობა, რათა დარწმუნდით, რომ თქვენი მონაცემები ფორმატირებული სწორად,
და PHP შეიძლება დაუკავშირდეს.
>> ახლა, Meteor იყენებს ახალი პარადიგმა.
ეს არის უფრო თანამედროვე გზა გატარება მონაცემთა ბაზაში.
ეს ტექნოლოგია მოუწოდა MongoDB.
ისევე როგორც JavaScript, ჩვენ ვნახეთ, რომ ეს არ აქვს მნიშვნელობა, რა სახის მონაცემები ჰქონდა.
ყველაფერი იყო var.
ეს არ იყო charstar.
ეს არ იყო int.
ეს არ იყო struct.
ეს იყო მხოლოდ var ამ, var რომ.
>> MongoDB მუშაობს სახის იგივე გზით.
თქვენ არ უნდა განსაზღვროს თქვენი მაგიდები.
თქვენ არ უნდა ვთქვა მაგიდა აქვს სახელი, რომელსაც აქვს int.
მას, მე არ ვიცი, დოლარი, რომელიც ათობითი.
ეს მხოლოდ ამ JavaScript ობიექტები, ყველა ამ vars, არსებითად.
და ეს არის ძალიან ძლიერი გზა პროტოტიპი თქვენი app.
და ამიტომაც Meteor იღებს უპირატესობა ამ.
>> თუ ჩვენ წასვლა ნაბიჯი სამი, ვნახოთ, რა შეიცვალა.
თუ დავაკვირდებით todos HTML, არ არის ბევრი.
CSS არ შეცვლილა.
მაგრამ მცირე ცვლილება ვხედავთ HTML არის ჩვენ შეიცვალა, თუ როგორ ამოცანები განისაზღვრება.
ამოცანები არის ფუნქცია.
ეს ნიშნავს, რომ ყოველ დრო, რომელიც ჩვენ გვინდა ამოცანები,
ჩვენ ვაპირებთ, რომ აწარმოებს ამ ფუნქციას.
ეს არ დაბრუნდება ფუნქცია, როგორც ღირებულება.
>> Meteor ჭკვიანი რეალურად აწარმოებს ფუნქცია, რომ რაც ჩვენ გავიდნენ.
და ის დააბრუნებს ამ რამ მოუწოდა ამოცანები.
ჩვენ განსაზღვრული ამოცანების on line ერთი, და ეს Mongo კოლექცია.
Mongo გულისხმობდა მონაცემთა ბაზის Meteor იყენებს,
და ეს ახალი მხოლოდ იმას ნიშნავს, გადავდგათ ახალი კოლექცია, მას ამოცანები.
In MySQL, ეს იქნება ექვივალენტურია ეძებს მაგიდა სახელწოდებით ამოცანები.
Mongo აქვს კოლექციებში, არ მაგიდები.
ასე რომ, ეს უბრალოდ გამოიყურება ამოცანები.
>> ახლა, template ჩვენს დამხმარე template, ყველა
ჩვენ უნდა გავაკეთოთ მისაღებად ყველა ამოცანები ამ ფუნქციის იპოვნით
და ეს ცარიელი გაუწიოს.
ეს უფრო კერძოდ, Mongo სინტაქსი.
არსებობს უამრავი დოკუმენტაცია ონლაინ როგორ
თქვენ შეგიძლიათ ეფექტური და ნამდვილად სასარგებლო Mongo შეკითხვებს.
მაგრამ რაღაც ეს კარგი საკმარისია მხოლოდ მოძიებაში ყველა მონაცემები.
>> ახლა, ერთ-ერთი საკითხი, რომ თქვენ შეიძლება ვხედავთ ის არის, რომ ჩვენ არასოდეს რეალურად დაამატოთ მონაცემები.
რა ხდება, როდესაც ჩვენ რეალურად აწარმოებს ნაბიჯი სამი?
მოდით სწრაფად წასვლას ნაბიჯი სამი და აწარმოებს Meteor.
შეამჩნია, რომ მე მქონდა კიდევ Meteor პროექტის გაშვებული სხვაგან,
ასე Meteor არ მოსწონს, რომ.
მე უბრალოდ აპირებს სწრაფად ახლოს სხვა Meteor კონტროლის C,
წასვლას ნაბიჯი სამი, და აწარმოებს Meteor ერთხელ.
შეამჩნია ის იწყებს MongoDB რადგან MongoDB
არის ნაწილი ყველა Meteor პროექტი.
>> ასე რომ ამბობს ჩემი განაცხადი შეცდომები.
ეს არის ლამაზი ფუნქცია Meteor აქვს.
რაც დარწმუნებული ვარ, თქვენი HTML კარგად დამტკიცდა.
მოდით სწრაფად შევხედოთ, თუ რატომ ეს შეიძლება იყოს.
როგორც ჩანს, მე არ შემთხვევით გადაწერა არასწორი HTML კოდი.
თუ გადაარჩენს ახლა, Meteor ავტომატურად განახლდება სერვერზე,
და ახლა app არის გაშვებული, როგორც მოსალოდნელი იყო.
შეამჩნია დაფიქსირება ამ, შეგიძლიათ აწარმოებს იგივე HTML ფაილი ნაბიჯი ორი,
ასლი ის ნაბიჯი სამი.
>> ჩვენ შეგვიძლია დავუბრუნდეთ ჩვენი ადგილობრივი მასპინძელი.
და ახლა ჩვენ ვხედავთ ჩვენ გვაქვს ჩვენი გავაკეთოთ სია.
დიდი, მაგრამ ეს ცარიელი.
ჩვენ არ რეალურად აქვს ამოცანები ჩვენს Mongo მონაცემთა ბაზაში.
ასე რომ, მოდით ვისაუბროთ რამდენიმე გზა ჩვენ შეგვიძლია ამის გაკეთება.
თუ ჩვენ უკან ტერმინალში, ჩვენ შეგიძლიათ დახუროთ ეს და აწარმოებს Meteor Mongo.
>> თუ თქვენ იცნობს თუ როგორ Meteor მუშაობს,
ეს რეალურად გაძლევთ ხელმისაწვდომობის საქართველოს სრული MongoDB for Meteor.
გაითვალისწინეთ, რომ თქვენ უნდა იყოს გაშვებული Meteor პირველი, რომ ეს მუშაობა.
ასე რომ, თუ მე აწარმოებს ამ ახალ tab, I შეიძლება დაბრუნდეს იგივე დირექტორიაში.
და ახლა Meteor მუშაობს მხოლოდ ჯარიმა.
ეს არის სწრაფი.
მიადევნე თვალი, რათა ის ცოტა დიდია ასე ვხედავთ.
ეს გამოიყურება ცოტა განსხვავებული, ვიდრე რა შეიძლება იყოს გამოყენებული, რათა თქვენ
ნამდვილად არ უნდა გამოვიყენოთ Mongo.
მთელი წერტილი ჩემთვის აქ არის ასე რომ თქვენ შეგიძლიათ გამოიყენოთ JavaScript.
მაგრამ თუ თქვენ საინტერესო, Mongo API არ
გამოყენება SQL, სტრუქტურირებული შეკითხვის ენა.
იგი იყენებს საკუთარი ენა, რომელიც ძალიან ჰგავს JavaScript.
ძალიან სწრაფად, ჩვენ შეგვიძლია მოვძებნოთ მაგიდა გავლით db.tasks.
და ის მეუბნებოდა თურმე, თუ ჩვენ აწარმოებს იპოვოს,
სახის მსგავსი იმისა, რაც ჩვენ გვქონდა Meteor, ჩვენ შეგიძლიათ გადაწეროთ ყველა ელემენტებს.
პრობლემა ის არის, რომ ჩვენ არ რეალურად რაიმე განსაზღვრული ამოცანების.
ასე რომ არ მიიღონ მათ.
>> ჩვენ შეგვიძლია ჩადეთ, თუმცა.
ასე რომ, ჩვენ შეიძლება აწარმოებს ჩასმა ბრძანება ჩანართით.
და ჩვენ უბრალოდ მისცეს მას ობიექტი, და ჩვენ უბრალოდ
დარწმუნდით ფორმატი რასაც ჩვენ ველით.
თუ ჩვენ შევხედე ნაბიჯი ორი, ჩვენ ვნახეთ, რომ ყველა ამოცანა
იყო ობიექტის ტექსტი როგორც გასაღები და რაც
თქვენი უნდა გავაკეთოთ ნივთი იყო, როგორც ცვლადი.
ასე რომ, ჩვენ შეგვიძლია გავაკეთოთ რაღაც აქ.
>> ჩვენ შეიძლება ჰქონდეს მას ჩადეთ ამოცანა ე.წ. მე მოვდივარ Mongo.
და დააჭირეთ Enter, და ის მუშაობს.
ჩვენ შეგვიძლია მას მოვთხოვოთ ისევ, და ჩვენ ვხედავ, რომ ობიექტი აქ.
Mongo ანიჭებს მას ID, რომელშიც თქვენ ნამდვილად არ უნდა ფიქრი.
რა არის მნიშვნელოვანი თქვენთვის არის მონაცემები თქვენ დააყენა, არის მონაცემები გავიდნენ.
>> მოდით დავუბრუნდეთ ჩვენი ნახვა, და hey, ჩვენი ამოცანაა, დატვირთული.
და თქვენ ხედავთ, რომ იმიტომ, რომ Meteor არის ძალიან ჭკვიანი
და ყოველთვის ამხნევებს, მე არ უნდა შეეხოთ გვერდზე.
ეს ავტომატურად დატვირთული.
>> მოდით აწარმოებს გარკვეული კოდი JavaScript თუმცა ამის გაკეთება.
როგორც ჩვენ Node უკან ბოლომდე შეასრულოს out JavaScript,
ჩვენ ასევე აწარმოებს JavaScript პირდაპირ ჩვენი ბრაუზერებში.
თქვენ შეგიძლიათ ამის გაკეთება ფუნქცია მოუწოდა შეამოწმოს Element.
თუ მე დააკლიკეთ მარჯვენა მონაკვეთზე გვერდზე,
არსებობს ვარიანტი მოუწოდა შეამოწმოს Element.
თუ თქვენ გაშვებული ბრაუზერი, როგორიცაა Safari, თქვენ
შეიძლება საჭირო, რათა თქვენი დეველოპერი ინსტრუმენტები სანამ ეს ფუნქცია.
>> რაც ჩვენ აღელვებს, რომ კონსოლი.
ასე რომ, ჩვენ უბრალოდ წასვლა console ბოლოში.
ახლა ჩვენ შეგვიძლია აწარმოებს ნებისმიერი JavaScript აქ, ისევე როგორც JavaScript
ფაილი I აჩვენა js მაგალითად.
მაგრამ ახლა მოდით შევხედოთ ამოცანები.
ჩვენ შეგვიძლია მას მოვთხოვოთ ჩვენი ბრძანება.
და იმედია გექნებათ, რათა ის ცოტა დიდია, ასე რომ ჩვენ შეგვიძლია ყველა ვხედავთ.
>> თუ ჩვენ აწარმოებს tasks.find, და თქვენ ვხედავ, რომ ეს ზუსტად იგივე კოდი
რომ JavaScript ფაილი მიზნებისათვის ნაბიჯი სამი, ეს task.find.
ჩვენ შეგვიძლია აწარმოებს იგივე, და ახლა ჩვენ რაღაც უცნაური პერსონალი.
როგორ ჩვენ რეალურად მისაღებად მონაცემები?
ასევე, ჩვენ უნდა აწარმოებს ამ ბრძანება მოუწოდა მისაღებად.
>> ეს არის ძალიან სასარგებლო debugging.
რაც თქვენ აქ არის კურსორი, და ეს არის
ლამაზი გზა Meteor აქვს ოპტიმიზირებულია მიღება მონაცემები.
ამ კურსორი აქვს ყველა თვისებები ცოცხალი განახლება და გამაგრილებელი გვერდი
როდესაც რაღაც შეიცვალა.
მაგრამ ეს არ მიიღოთ ჩვენს მონაცემები.
ჩვენ შეგვიძლია მივიღოთ მონაცემების მეშვეობით მოიტანონ.
და ხედავთ, ჩვენ გვაქვს ობიექტი, და ის ისევე რაც გვქონდა Mongo,
პირადობის და ტექსტი ჩვენ დააყენა.
>> ასე რომ, ჩვენ ჩადეთ ნივთის Meteor?
ასევე, ჩვენ უბრალოდ უნდა ამოცანები.
და მაშინ ჩვენ შეგვიძლია მას მოვთხოვოთ იგივე ჩანართით ბრძანება,
ვაძლევთ ლექსიკონი ან ობიექტი იგივე ფორმატში, ტექსტი
და მერე მოდის კონსოლი.
შეხედეთ ზემოთ, რადგან როდესაც მე ამისათვის, იგი აჩვენებს up on ნახვა
ავტომატურად.
>> გაითვალისწინეთ, რომ თქვენ შეგიძლიათ განათავსოთ რაიმე გსურთ ეს საკითხი.
ეს არ უნდა ფიქსირებული სტრუქტურა.
მე ვერ აქვს ტოლია ნომერი სამი და b ტოლია ყალბი.
და ეს ყველაფერი მუშაობს.
მე კი აირჩიოს არ მათ შორის ტექსტური ყველა.
ეს უბრალოდ არ არის რეკომენდირებული თუმცა იმის გამო, მაშინ Meteor
არ ვიცი, რა ცარიელია.
მაგრამ ყოველ შემთხვევაში, ჩვენ მიიღეთ ID, და ეს
ID ობიექტი თქვენ შეგიძლიათ გამოიყენოთ.
>> როგორც ჩვენ ვაგრძელებთ დახევას ოთხ და ნაბიჯ ხუთ,
სამეურვეო გაჩვენებთ გზები, რომ თქვენ შეგიძლიათ შექმნათ UI ელემენტები გამოყენებით
HTML იცით შექმნა სხვადასხვა ამოცანები.
მოდით შევხედოთ ნაბიჯი ოთხი მართლაც სწრაფად.
ჩვენ დავინახავთ, რომ ჩვენ დამატებული მონაკვეთზე განვითარებული მოვლენების შესახებ.
თარგები შეიძლება ჰქონდეს დამხმარე, რომელიც მიიღებს us მონაცემები.
მაგრამ მას ასევე შეუძლია მოვუწოდებთ მოვლენები.
და ეს არის სადაც პერსონალი ხდება სასარგებლოა, რადგან მოვლენების
არიან რა მოხდება მაშინ, როდესაც თქვენ დააჭირეთ სხვადასხვა რამ თქვენი ნახვა.
>> აქ, ჩვენი კოდი არის ვეუბნებოდი გვაძლევს დაამატოთ ეს ღონისძიება.
სანიშნეს ეს მაშინ, როდესაც თქვენ წარმოდგენილი რაღაც კლასში ახალი დავალება.
რაც თქვენ აქ არის CSS selector.
ასე რომ, ეს უბრალოდ გამოიყურება HTML ელემენტს, რომლის კლასის ახალი დავალება.
და ეს გამოიყურება ღონისძიება, როგორიცაა წარუდგინოს.
სხვა მოვლენების მოიცავს click, hover, ორმაგი დაჭერით,
მსგავსი, რაც თქვენ მიიღებთ ნორმალურ HTML.
>> რას აძლევს ეს აქ არის ფუნქცია.
და თქვენ შეგიძლიათ თქვენი კოდი რომ ფუნქცია.
ეს ფუნქცია არის ის, რაც მთავრდება მისაღებად მოუწოდა, როდესაც თქვენ წარმოადგინოს ამ ახალი დავალება.
მოდით შევხედოთ HTML მხოლოდ ასე მესმის რა ეს ახალი ამოცანა.
ჩვენ დასძინა ფორმა აქ კლასის ახალი დავალება.
და მას აქვს input, რომელიც იღებს ტექსტი.
და ეს არის სადაც ჩვენ დავუმატებთ ჩვენი ახალი ამოცანები.
>> მოდით აწარმოებს ნაბიჯი ოთხი ნახვა დაინახოს, რას ჰგავს.
ჩვენ შეგვიძლია დატოვა პირველი out საქართველოს MongoDB გვქონდა
ჩვენი წინა მაგალითად, კონტროლის C.
და მოდით შეცვალოს იგი ნაბიჯი ოთხი დირექტორია.
ჩვენ აწარმოებს Meteor ერთხელ დაიწყოს სერვერზე.
და სამწუხაროდ, მე მქონდა Meteor გაშვებული მეორე ტერმინალში.
ამიტომ მე უბრალოდ აპირებს დარწმუნდით, რომ ეს იხურება.
მოდით დატოვა ამ და ცვლილება ნაწილი ოთხი, დახევას ოთხ.
OK.
>> ახლა ჩვენი Meteor კოდი გაშვებული.
და თქვენ ხედავთ, რომ ეს განახლება, გარეშე us კი, რომელსაც ამოცნობა გვერდზე.
რა შეიცვალა აქ არის რომ ჩვენ არ გვაქვს რაიმე ამოცანები,
მაგრამ ჩვენ გვაქვს ფორმა აქ, ამ ტექსტში ყუთი, დაამატოთ ჩვენი ახალი ამოცანები.
და ჩვენ შეგვიძლია აკრიფოთ ჩვენი ამოცანა აქ.
მე მოვდივარ HTML გვერდზე.
როდესაც მე დააჭირეთ Enter, მას წარმოდგენილი.
>> ჩვენ ვხედავთ, თუ რა მოხდა, განისაზღვრება JavaScript კოდი.
რა ამ ფუნქციის გააკეთა, ეს იყო მიიღოს ტექსტის სახით,
და მხოლოდ მაშინ მოუწოდა tasks.insert, როგორც ჩვენ გავაკეთეთ კონსოლი.
ისინი ასევე აირჩია დაამატოთ createdAt თარიღი.
ეს არის, თუ როგორ განსაზღვროს მიმდინარე დრო.
ამის შემდეგ, იგი გაასუფთავებს სახით მიღების დარწმუნებული ვარ, ღირებულება არის ცარიელი.
>> და მაშინ ის მოუწოდებს დაბრუნდეს ყალბი დარწმუნდით, რომ სხვა არაფერი ხდება.
როდესაც თქვენ დაბრუნების ცრუ საწყისი ფორმა ღონისძიება, რომელიც აჩერებს აღსრულებას.
ამბობენ ფორმით აქვს აქცია, როგორიცაა წარუდგინოს PHP გვერდზე.
თუ არ დაბრუნდა ცრუ, ნეტავ დაბრუნდეს ჭეშმარიტი.
ეს იქნებოდა დასრულდება up მიღების მოთხოვნა.
ცრუ საუბრების და აჩერებს მას უფლება არსებობს.
>> ასე რომ იყო პატარა დემო შესახებ როგორ Meteor მუშაობს, და ჩვენ გვაქვს
უკვე შემდეგ tutorial ხნით.
და თქვენ შეგიძლიათ, გთხოვთ, უფასო გააგრძელოს ამით.
არსებობს უამრავი რესურსი, და სამეურვეო რეალურად მხოლოდ
ძალიან კარგი აეხსნა რა ხდება.
მე მინდა გაჩვენოთ ახლა, რამდენიმე წუთში ჩვენ არ დაუტოვებიათ,
რა არის ზოგიერთი cooler თვისებები Meteor,
და რა არის ზოგიერთი უფრო სასარგებლო პაკეტები.
ერთი დიდი რამ Meteor არის, რომ თქვენ გაქვთ პაკეტი სისტემა.
თქვენ შეგიძლიათ მარტივად ჩართული კოდი რომ მრავალი ათასი დეველოპერები
არ წერია მსოფლიოში თქვენი Meteor პროექტი.
ერთ-ერთი მაგალითია, ეს არის ის, რაც თქვენ შეიძლება ნუ ნაბიჯი ცხრა tutorial, სადაც
თქვენ ცდილობთ რჩეულებში ანგარიშები თქვენი Meteor პროექტი.
თუ ჩვენ გვაქვს CS50 PHP პროექტის, ჩვენ უნდა
დაეყრდნონ ფარგლებში ან ჩვენივე კოდი რათა
დარწმუნებული ვარ, ჩვენ უსაფრთხოდ გაუმკლავდეს პაროლები და სახელები
და შენახვის მონაცემთა ბაზაში და ყველა რომ.
>> თურმე Meteor აქვს პაკეტი უნდა გავაკეთოთ, რომ თქვენ,
და ამის გაკეთება ძალიან ადვილად.
რა შეგვიძლია გავაკეთოთ არის დაამატოთ რამდენიმე პაკეტი.
მოდით გავაკეთოთ, რომ უფლება ახლა ჩვენს კონსოლი.
მე ვაპირებ დატოვა პროექტი და ახლა წასვლას მარტივი todos.
ახლა, მარტივი todos არის პროექტი, რომელიც თქვენ
ექნება მას შემდეგ, რაც კეთდება ნაბიჯი 11 ან ნაბიჯი 12
ბოლოს ამ tutorial.
და მოდით სწრაფად შევხედოთ ეს უნდა ნახოთ რა განსხვავებული თვისებები გვაქვს.
მოდით უბრალოდ დარწმუნდით, რომ იგი გაშვებული.
ზოგჯერ ეს ხდება მაშინ, როდესაც ამოცნობა, მაგრამ აქ არის.
>> ჩვენ გვაქვს ჩვენი ვარიანტი დამალვა სრული ამოცანები, და ჩვენ შეგვიძლია მოაწეროს.
და ეს ყველაფერი კეთდება Meteor პაკეტი.
ეს არის დიდი.
ჩვენ ახლა username და პაროლი ნიშანი.
მაგრამ რა, თუ გვინდოდა დაამატოთ სხვა სახის ტიპის მექანიზმი?
ვთქვათ, მე მინდოდა, რომ შეხვიდეთ ჩემს Meteor ანგარიში.
მე ვაპირებ აწარმოებს meteor დამატება და ამ არის სინტაქსი დასძინა პაკეტები.
შემიძლია ვთქვა, ანგარიშები, და accounts.meteor.
ის აპირებს ახლა პაკეტები და ჩატვირთოს ის.
თქვენ ხედავთ, რომ მე არ ი უფლება პაკეტი სახელი.
>> ასე რომ, თქვენ გასარკვევად პაკეტები?
ასევე არსებობს დიდი ნახვა, გააკეთა ხელმისაწვდომი Meteor ადამიანი,
მოუწოდა atmospherejs.com.
Atmospherejs, ერთი სიტყვით, dot com, დიდი საცავი
მოძიების ყველა Meteor პაკეტი საცავი.
მე ვერ მოძებნა ანგარიშები, და მაშინ ეს თქვენ ეჩვენებინა ყველა შესაბამისი პერსონალი,
ყველა პაკეტების ანგარიშის სახელი.
>> მიუხედავად იმისა, რომ ტვირთავს, ჩვენ შეგვიძლია ვცდილობთ დამატებით რამდენიმე სხვა პაკეტები.
იქნებ Meteor პაკეტი არ მუშაობს ახლა, მაგრამ შემიძლია ვთქვა Facebook.
შემიძლია ვთქვა ანგარიშზე და შემდეგ აწარმოებს Meteor პროექტის ერთხელ.
მას შემდეგ, რაც ამ იწყება, ვნახოთ, რა შეიცვალა ვებგვერდზე.
თქვენ შეგიძლიათ ვხედავ მე შეიძლება უნდა ამოცნობა აქ.
>> მაქვს ღილაკს კონფიგურაციის Facebook შესვლა.
და აქ, მაქვს ყველა ინსტრუქციას Meteor
მოამზადა თქვენთვის შექმნის Facebook app.
და თქვენ შეგიძლიათ გამოიყენოთ ინფორმაცია დაამატეთ თქვენი პირადობის მოწმობა.
ერთხელ რომ კეთდება, თქვენ უნდა Facebook- ის მუშაობს თქვენი app.
>> მე უბრალოდ აპირებს მიიღოს app ID და საიდუმლო,
უბრალოდ გაჩვენებთ თუ როგორ შეიძლება მუშაობა.
თქვენ უნდა Facebook ანგარიშის გამოიყენოს Facebook დეველოპერი პარამეტრები.
ნება მომეცით სწრაფად იპოვოს Meteor გასაღებები, რომლებიც აუცილებელია.
მაქვს კიდევ ერთი Meteor პროექტი რომ მე ვაპირებ გამოყენება,
და მე უბრალოდ აპირებს გასაღებები რომ ფაილი.
>> და კიდევ მე ეს, მე მხოლოდ შეძლებს კოპირება ამ გასაღებები ჩემს Facebook.
ასე რომ, აქ არის გასაღები.
და ეს არის საიდუმლო.
თქვენ არ უნდა იყოს გაზიარების ეს ადამიანი.
და შემდეგ მისცეს მას თქვენი app საიდუმლო.
და ეს იმდენად Facebook იცის, რომ თქვენ ხართ.
და თქვენ გადარჩენა კონფიგურაცია.
>> მე ვფიქრობ, რომ ამ პროცესში I არ შემიწყვეტია Meteor app.
ასე რომ, მე უბრალოდ მინდა დარწმუნებული ვარ, ეს ჯერ კიდევ არსებობს.
კარგით, მოდით, იმისათვის, რომ ჩვენი Meteor სერვერზე გაშვებულია ისე ვებ გვერდზე მიმდინარეობს.
შეამჩნევთ, თუ ჩვენ შეწყვიტოს Meteor სერვერზე, გვერდი ჯერ კიდევ არსებობს.
უბრალოდ არ განახლება აღარ.
Meteor სერვერზე აუცილებელია მიღების დარწმუნებული ვარ, რომ გვერდზე ცოცხალი.
>> OK, მე წარმოდგენილი, და ახლა მე შემიძლია შეხვიდეთ Facebook.
ახლა ეს მხოლოდ დროის საკითხია რომელსაც Facebook pop up
და აყენებს თქვენს ანგარიშზე ინფორმაცია და ხე.
მას შემდეგ, რაც თქვენ, რომ, Facebook, შესაძლოა, nag თქვენ გარკვეული უსაფრთხოების მეტი.
ასე რომ, ჩვენ უბრალოდ მთავრდება.
საქმე ისაა, რომ როდესაც თქვენ გაკეთდეს რომ, თქვენ უნდა Facebook შესვლა.
>> Meteor აქვს რამოდენიმე სხვა პაკეტების ისევე.
თქვენ შეგიძლიათ შეხვიდეთ Google+.
თქვენ შეგიძლიათ შეხვიდეთ GitHub.
თქვენ შეგიძლიათ შეხვიდეთ Twitter.
ან თუ თქვენ მოძებნოთ, თქვენ უამრავი სხვა რამ
როგორიცაა Meetup, LinkedIn, და Meteor შემქმნელი.
ასე Meteor შემქმნელი იყო პაკეტი I ეძებდა.
მსუბუქი რჩეულებში ანგარიშები-meteor-დეველოპერი.
ამასობაში, მე ასევე მინდა რეკომენდაცია
ზოგიერთი სხვა პაკეტების თქვენი პროექტები.
ეს შეიძლება ძალიან სასარგებლო აღმოჩნდეს, მოიცავს jQuery პაკეტი.
ეს საშუალებას გაძლევთ გამოიყენოთ jQuery თქვენს კლიენტებს.
თქვენ შეიძლება უბრალოდ ეს ერთი ხაზი, და Meteor დარწმუნდით, რომ თქვენ დღემდე
on jQuery.
მე ასევე რეკომენდაციას houston: admin.
>> ეს არის ერთგვარი მოსწონს phpMyAdmin სახის ინსტრუმენტი თქვენი MongoDB.
ეს გაძლევთ საშუალებას შეცვალონ თქვენი მონაცემები საკმაოდ მარტივად
გარეშე წასვლა Mongo shell, როგორც მე გაკეთდეს ადრე მონაწილეობას.
ასე, რომ ახლა რომ გაშვებული გავუშვათ Meteor ერთხელ და ვნახოთ რა შეგვიძლია გავაკეთოთ.
>> თქვენ შეამჩნევთ, რომ დამატებით რამდენიმე პაკეტები შესაძლოა, მათ წარმოადგინოს რამდენიმე გაფრთხილება.
თქვენ არ გჭირდებათ ფიქრი შესახებ, რომ houston.
ასე რომ ჩვენ შეგვიძლია ახლა ვარიანტი კონფიგურაციის Meteor admin.
და მათ მოგცემთ მიმართულებები თუ გსურთ, რომ მითითებული up.
>> ჩვენ შეგვიძლია ასევე ახლა წასვლა / admin.
ეს ჩამოიყვანს თქვენ მიერ houston პაკეტი.
და ეს არის Meteor admin ინტერფეისი.
თქვენ უბრალოდ შექმნათ admin ანგარიშზე, როგორიცაა ასე.
და თუ თქვენ განაახლეთ გვერდი, თქვენ შეიძლება აქვს გარკვეული კოლექციები გვიჩვენებს up.
>> ეს არის ძალიან სასარგებლო ინსტრუმენტი, და მე გირჩევთ ეს.
თქვენ ხედავთ, რომ იმის გამო, houston აძლევდა გარკვეული შეცდომები,
ჩვენ არ გვაქვს რაიმე კოლექცია ნაჩვენებია up ახლავე.
ისე გამოიყენებს houston არის მიღების დარწმუნებული ვარ, რომ ეს ფუნქცია იღებს
მოუწოდა თქვენს მარტივი todos.
ასე houston არ იცით, რა ჩემი ამოცანა.
>> ჩვენ შეიქმნა Mongo კოლექცია მოუწოდა ამოცანები.
მოდით წასვლას მარტივი todos და მხოლოდ დარწმუნდით, რომ JavaScript,
ჩვენ დასძინა დავალებები ჩვენს კოლექციებში.
ჩვენ ახლა გადაარჩინა, და ის აშენებს განაცხადი, განაახლოს.
და ვნახოთ.
ახლა ჩვენ გვაქვს გარკვეული ამოცანები.
და ჩვენ შეგვიძლია დაამატოთ რამდენიმე ახალი ამოცანები.
მაგრამ თუ ჩვენ გვინდა, რომ დაამატოთ ამოცანები, მოდით ერთად app თავად.
>> ახლა ჩვენ შეგვიძლია დამატება ზოგიერთი მონაცემები.
Hi, ეს არის ამოცანა.
როგორც ჩანს, ასეთი უცნაურია, რომ ჩვენ არ ხედავს რაიმე ამოცანები.
ჩვენ დაგვჭირდება შეამოწმეთ თუ მივიღეთ ნებისმიერი შეცდომები აქ, ან იქნებ სადმე სხვაგან.
თუ ჩვენ წასვლას admin, რომელიც, როგორც ჩანს, უცნაურია.
თუ თქვენ დახევის საცავი მას შემდეგ, რაც ამ სემინარზე,
მე დარწმუნდით, რომ მარტივი todos მუშაობს houston.
სამწუხაროდ, ეს არ ჩანს იყოს მუშაობს ამ მომენტში.
>> არსებობს რაიმე სხვა კითხვები?
Houston ნორმალურად არის ინსტრუმენტი, რომელიც ძალიან კარგად მუშაობს.
Houston კონკრეტულად bit buggier ვიდრე სხვა,
მაგრამ მე გირჩევთ, როდესაც იგი მუშაობს.
Yeah.
>> აუდიტორია: რა შეგიძლიათ გააკეთოთ, ერთად Facebook პაკეტი
ერთხელ მომხმარებელი ხართ წელს მათი Facebook?
>> ROGER ZURAWICKI: Once მომხმარებლის ანკეტის ხართ შესული სისტემაში,
თქვენ შეგიძლიათ ზარები Facebook API.
ბევრი რომ დევს მეტი როგორ Facebook ხსნის მათი API.
Meteor, დარწმუნდით, რომ თქვენ აქვს კავშირი.
მაგრამ ყველაფერი მას შემდეგ, რაც ეს არის საკითხი სწავლა, თუ როგორ გამოიყენოთ Facebook API.
აუდიტორია: [INAUDIBLE].
ROGER ZURAWICKI ყველა უფლება.
ძალიან დიდი მადლობა ამისთვის ამ CS50 სემინარი Meteor.
თუ თქვენ გაქვთ რაიმე შეკითხვები, თქვენ შეგიძლიათ მომაწოდეთ
ჩემი ელექტრონული ფოსტის მისამართი ქვემოთ ჩამოთვლილი სემინარს.
და მე ვიქნები ბედნიერი უპასუხოს თქვენს შეკითხვებს.
მე ასევე იყოს CS50 Hackathon უნდა
თქვენ უნდა დაეხმაროს თქვენი Meteor პროექტები.
გმადლობთ თვალს.