სტატიის ადაპტირებული თარგმანი "სრული Stack JavaScript ექვსი კვირის განმავლობაში: სასწავლო სახელმძღვანელო"

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

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

რატომ JavaScript?

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

საფუძველი

თავდაპირველად აუცილებელია JavaScript- ის ძირითადი კონცეფციების შესწავლა, ვებ-გვერდის განვითარება და პროგრამირება მთლიანად:

• ობიექტზე ორიენტირებული JS - დიზაინერები და ქარხნები, მემკვიდრეობა;
• ფუნქციური JS - უმაღლესი წესრიგის ფუნქციები, დახურვა, რეკურსია;
• ჟასმინის ტესტი სპეციფიკაცია;
• hTML, CSS და JQuery საფუძვლები.

Git.

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

• ფაილების შექმნა და მოძრავი დირექტორიები;
• ინიციალიზაცია და ჩაიდინა git;
• განთავსება საცავებში GitHub- ში.

ალგორითმები და მონაცემთა სტრუქტურები

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

დუღა

Node.js.

10 წლის წინ, Javascript შეიძლება გამოყენებულ იქნას მხოლოდ Frontend განვითარებისათვის. ახლა მადლობა Node.js, საქმე არ შემოიფარგლება ერთი "წინა". კვანძი არის მხოლოდ გარემოს შესასრულებლად JS კოდი სერვერზე მხარეს, ასე რომ თქვენ არ უნდა შეისწავლოს ახალი სინტაქსი, მაგრამ თქვენ უნდა იმპორტი და ექსპორტის ფაილები, გაყოფილი კოდი მოდულები და გამოიყენოთ NPM პაკეტის მენეჯერი.

სერვერები, http, express.js

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

ასინქრონული JavaScript.

მონაცემთა ბაზები, სქემები, მოდელები და ორმ

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

წარმტოვეტი

HTML და CSS.

HTML და CSS არის ფონდების საფუძველი ნებისმიერი ვებ დეველოპერი. თქვენ არ უნდა იცოდეთ ისინი კარგად, მაგრამ მათ უნდა გაიგოთ ისინი. თქვენ ასევე შეგიძლიათ შეისწავლოთ ნებისმიერი პოპულარული ბიბლიოთეკა (მაგალითად, bootstrap) და CSS preprocessor მოსწონს Sass - ის დაეხმარება CSS მსგავსი ჩვეულებრივი კოდი. გამარტივება მუშაობა HTML- ით, თქვენ შეგიძლიათ აირჩიოთ ერთი პოპულარული templateizers, მაგალითად, pug.

jQuery და მანიპულირება dom

შეიქმნა გვერდის გამოჩენა დახმარება HTML და CSS, თქვენ გამოიყენებთ jQuery ბიბლიოთეკა გააკონტროლოს DOM. ბევრი მიიჩნევს, რომ jQuery არის უსარგებლო და მალე შეიცვლება კუთხოვანი და რეაგირება, მაგრამ ეს არის insanely პოპულარული, და ამიტომ ღირს იცის. გარდა ამისა, ერთ დღეს თქვენ მოხვდებიან სიტუაციაში, სადაც არასასიამოვნო იქნება, რომ რეაგირება მიკროსკოპი, და შემდეგ ადვილი jQuery მოვა სამაშველო.

Chrome დეველოპერის ინსტრუმენტები

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

აიაქსი

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

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

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

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

ზოგადი ინფორმაცია

ბევრი ადამიანი, მაშინაც კი, მას არ უკავშირდება ეს სფეროს, მოისმინა სიტყვა Java. რევოლუციური დამოუკიდებელი ენა ენაზე, რომელზეც აპლიკაციები აქტიურად წერენ მობილური სისტემები. იგი შემუშავდა პერსპექტიული Sun კომპანია, რომელიც შემდეგ გადაკვეთა "ქვეშ ფრთის" Oracle. მაგრამ არც ერთი და არც სხვა კომპანიებს არაფერი აქვთ საერთო JavaScript- ით:

მზეზე მხოლოდ ნებართვა გამოიყენებოდა სახელით. გასაკვირია, JavaScript არ ფლობს ნებისმიერ ფირმას.

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

• Ობიექტზე ორიენტირებული. პროგრამის აღსრულება ობიექტების ურთიერთქმედებაა;
• მონაცემთა ტიპების შემოტანა ავტომატურად ხორციელდება;
• ფუნქციები ბაზის კლასის ობიექტებია. ეს ფუნქცია ხდის JavaScript- ს მრავალი ფუნქციური პროგრამირების ენაზე, როგორიცაა Lisp და Haskell;
• ავტომატური მეხსიერების დასუფთავება. ე.წ. ნაგვის კოლექცია ხდის JavaScript- ს C # ან Java- ს.

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

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

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

JavaScript- ზე მარტივი კოდი გამოიყურება:

განაცხადის ფარგლები

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

• ვებ აპლიკაციის განვითარება. გსურთ დააყენოთ მარტივი Counter, მოაწყოს მონაცემთა გადაცემის ფორმები ან დააყენა თქვენს საიტზე თამაში? შემდეგ JavaScript ამ საკითხში ერთგული თანაშემწე გახდის;
• "აქტიური მონაწილეობა" AJAX- ში. ეს ტექნოლოგია მნიშვნელოვნად აჩქარებს აპლიკაციებს, სერვერზე მონაცემთა გაცვლის განხორციელება "ფონზე" რეჟიმში:

• Os. ალბათ, ვინმემ არ იცის, მაგრამ Windows, Linux და Mac- ს ბრაუზერის კონკურენტები, კოდექსის ლომის წილი JavaScript- ში დაწერილია;
• მობილური აპლიკაციები;
• ტრენინგის ფარგლები. უნივერსიტეტში ნებისმიერი პროგრამისტი სპეციალობით მოიცავს JavaScript- ის შესწავლას ერთ გზაზე ან სხვა. ეს არის იმის გამო, რომ ენა თავდაპირველად განვითარდა არ არის ძალიან ძლიერი პროგრამისტებისთვის. JavaScript გაკვეთილები ლოგიკურად ნაქსოვი ბაზის HTML კურსს, ამიტომ განვითარება უბრალოდ საკმარისია.

Დადებითი და უარყოფითი მხარეები

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

• საჭიროა ჯვარი ბრაუზერის უზრუნველსაყოფად. მას შემდეგ, რაც JavaScript მოქმედებს როგორც ინტერნეტ ტექნოლოგია, მაშინ თქვენ უნდა დააყენოს წესები, რომლებიც დაამყარონ მსოფლიო ქსელი. კოდი უნდა შესრულდეს სწორად, ან თუნდაც ყველაზე პოპულარული, ბრაუზერები;
• მემკვიდრეობის სისტემა ენაზე იწვევს სირთულეებს, თუ რა ხდება. JavaScript- ის პროტოტიპებზე დაფუძნებული მემკვიდრეობა. ადამიანები, რომლებიც სწავლობდნენ სხვა ობიექტზე ორიენტირებული პროგრამირების ენებს, რომლებიც ჩვეულებრივად მიჩენილია " კლასის შთამომავალი მემკვიდრეობით" მაგრამ JavaScript- ში, ასეთი რამ არის პირდაპირ ობიექტებში, და ეს არ შეესაბამება ხელმძღვანელს;
• Არდამსწრე სტანდარტული ბიბლიოთეკა. Javascript არ ითვალისწინებს ნებისმიერ შესაძლებლობებს, რომ ფაილებთან მუშაობა, I / O ნაკადები და სხვა სასარგებლო ნივთები;
• სინტაქსი, როგორც მთელი, ძნელი გასაგებია. კოდექსის სილამაზე აშკარად არ არის JavaScript Rustle, მაგრამ პროგრამისტების ძირითადი წესი აღინიშნება: " მუშაობს? Არ სცადო!».

ახლა აღსანიშნავია გარკვეული უპირატესობები

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

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

მათთვის, ვისაც სურს სწავლა

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

• უპირველეს ყოვლისა, HTML. შეუძლებელია, რომ ინტერნეტში რაღაცის გაკეთება დაიწყოს საფუძვლების საფუძვლების გარეშე. კასკადური სტილის ფურცლები (CSS) ძალიან სასარგებლო იქნება;
• ახალი ლიტერატურის გამოყენება. პროგრამირება არ არის ფიზიკა, რომლის კანონები აუცილებელია და ახალი სახელმძღვანელოები ძველია. IT ტექნოლოგიები მუდმივად ვითარდება და არ უნდა იყოს უგულებელყოფილი სასარგებლო განახლებებით;
• ცდილობენ პროგრამის ყველა მონაკვეთს დაწერონ. თუ რამე არ არის ყველა აღმოჩნდება - თქვენ შეგიძლიათ სესხის სხვისი კოდი, მაგრამ მხოლოდ წინასწარ გაგება თავს ყველა ხაზი;
• Debugging არის თქვენი ერთგული მეგობარი. სწრაფად იპოვოს შეცდომები - ერთი ყველაზე მნიშვნელოვანი პუნქტები პროგრამირებაში;
• არ იგნორირება ფორმატირება ნორმები. რასაკვირველია, კოდექსი არ იქნება უკეთესი ან უარესი სხვადასხვა რაოდენობის ინტენსიური და სივრცეები, მაგრამ წაკითხვისა და გააზრების პროგრამისტი ასევე მნიშვნელოვანია. ქვემოთ მოცემული კოდი? ძალიან რთული აღიქმება, განსაკუთრებით თუ არ ხართ მისი

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

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

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

ამ ასპექტების გათვალისწინებით, დავიწყოთ ...

რა არის fizzizbiz ტესტი

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

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

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

მაგალითი კლასიკური fizzizbizz ტესტი:

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

For (var i \u003d 1; მე<= 100; i++) { if (i % 15 == 0) { console.log("FizzBuzz"); } if (i % 3 == 0) { console.log("Fizz"); } if (i % 5 == 0) { console.log("Buzz"); } }

განსხვავება \u003d\u003d და \u003d\u003d\u003d

თქვენ ალბათ იცნობთ ორივე შედარების ოპერატორს. მიუხედავად ამისა, იცით, რა ზუსტად ეს ოპერატორები განსხვავდება? შენი JavaScript Linter მოითხოვს თქვენ გამოიყენოთ ოპერატორი \u003d\u003d\u003d, რატომ?

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

Console.log (24 \u003d\u003d "24"); // სიმართლე.

როგორც ხედავთ, 24-ის სიმებიანი ღირებულება (ერთ ციტატებში) გადაეცა რიცხვზე. რა თქმა უნდა, არსებობს სიტუაციები, სადაც თქვენ ზუსტად და თუ გინდა, მაგრამ ყველაზე ხშირად თუ გსურთ თუ არა შედარების ოპერატორის მანიპულირებული მონაცემთა ტიპები. ოპერატორის გამოყენებით მონაცემების შედარება \u003d\u003d არ არის რეკომენდებული, JavaScript Style Code- ის შემოწმების საუკეთესო სისტემები მიუთითებს ამ შეცდომაზე.

\u003d\u003d\u003d (მკაცრი შედარება) ადარებს მონაცემთა ტიპებს, მათ გარეშე ერთი ტიპის, ანუ მონაცემები შედარებით იქნება. ასევე, რადგან ტიპის ტიპების ტიპი არ არის ჩართული ამ ოპერაციაში, მუშაობს სწრაფად. ისე, რომ ეს ოპერატორი სწორად ვრცელდება, საჭირო იქნება იმავე ტიპის ოპერატორები.

იგივე მაგალითია, მაგრამ ოპერატორთან \u003d\u003d\u003d

Console.log (24 \u003d\u003d\u003d "24"); // ცრუ

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

როგორ ავირჩიოთ DOM ელემენტები დამატებითი ბიბლიოთეკების გარეშე

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

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

არსებობს რამდენიმე მშობლიური მეთოდები, რათა მოძებნოთ ელემენტები Dom, რომლებიც არ არიან inferior to jQuery. ჩვენ ასევე შეგვიძლია გამოვიყენოთ პირველი შვილი, ბოლო ბავშვის ტიპის სელექტორები და ა.შ.

გაეცანით ამ მეთოდებს

• document.getelementbyid არის კლასიკური მეთოდი მათი ID- ის მიერ.
• დოკუმენტი.
• document.queryselector არის შესანიშნავი მეთოდი, რომელიც პრაქტიკულად მთლიანად შეცვლის $ () სელექტორი საწყისი jQuery, მაგრამ ეს უკვე შედის JavaScript. ერთადერთი განსხვავება ისაა, რომ ის მხოლოდ ნაპოვნია მხოლოდ პირველ ელემენტს.
• document.queryseletorl - წინა მეთოდის ანალოგი, მაგრამ დააბრუნებს ნაპოვნი ნივთების მასივში.
• document.getelmentsbytagname - ეს მეთოდი დაგეხმარებათ აირჩიოთ ელემენტები tag. თუ თქვენ უნდა მოძებნოთ ყველა div ელემენტი, მაშინ გჭირდებათ ეს მეთოდი.

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

Mozilla დოკუმენტაციაში თქვენ იხილავთ ამ მეთოდების სრულ აღწერას.

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

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

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

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

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

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

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

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

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

კონსოლი გუნდები

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

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

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

• console.log - გამოიყენება, რათა შეინარჩუნოს ღონისძიება შესვლა. მხარს უჭერს ფორმატირებას.
• console.Error - შესვლის შეცდომების კოდი. მე ამ ბრძანებას ვიყენებ, როდესაც შეცდომები ხდება AJAX- ის შეკითხვებსა და კოდექსის სხვა პოტენციურად საშიში მონაკვეთებში. მეთოდი მსგავსია წინა, მაგრამ ის აჩვენებს დასტის ზარების ჩამონათვალს.
• console.dir (ობიექტი) - აჩვენებს ობიექტის ფორმატირებული შინაარსს. როგორც ეს მეთოდი ძალიან სასარგებლოა კოდის გამართვისას.
• console.Group (სათაური) - საშუალებას გაძლევთ შექმნათ ჯგუფის შეტყობინებები შესვლა სახელწოდებით სახელწოდებით. ამ გზით, თქვენ შეგიძლიათ ჯგუფური შეტყობინებები, მაგალითად, კოდის სეგმენტში, სადაც ისინი გენერირდება.
• console.GroupCollPased არის წინა ბრძანების ანალოგი ერთი გამონაკლისი. კერძოდ, იგი აჩვენებს შეტყობინებებს დაკეცილი ფორმაში.
• console.Groupend - მთავრდება ადრე შექმნილი ჯგუფი.
• console.time.time (ლეიბლი) - საშუალებას გაძლევთ აკონტროლოთ სიჩქარე საიტი მილიწამებში. მეთოდი სასარგებლოა, როდესაც პოტენციურად კომპლექსური კოდის მონაკვეთების მიღება.
• console.TeeMend (ლეიბლი) არის ჯგუფის მეთოდის ანალოგი, მაგრამ ის მუშაობს კონსოლით.
• ასლი (სიმებიანი) - კონსოლი Chrome და Firefox- ში არის მეთოდი, რომელიც საშუალებას გაძლევთ კოპირების შინაარსი ბუფერში. ძალიან სასარგებლო მეთოდი, ცდილობენ გამოიყენონ იგი.

რა არის ზუსტად ეს

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

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

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

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

ფუნქცია MyFunction () (Console.log (ეს \u003d\u003d\u003d ფანჯარა); // სიმართლე) MyFunction ();

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

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

ამის შეცვლის ღირებულება სრულად ახალ ობიექტზე (არა ფანჯარა):

ფუნქცია MyFunction () (console.log (ეს \u003d\u003d\u003d window); // ცრუ) ახალი MyFunction ();

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

რატომ მოხდა ეს?

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

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

სიტყვის ახალი ამბების გამოყენებისას, სკრიპტის კონტექსტი გადადის ფანჯრის კონტექსტში API- ზე.

Var api \u003d (GetDATA: ფუნქცია () (console.log (ეს \u003d\u003d\u003d window); // ცრუ კონსოლი.ლოგი (ეს \u003d\u003d\u003d API); Api.getdata ();

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

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

უფრო დეტალურად საკვანძო სიტყვით JavaScript, შეგიძლიათ გაეცნოთ სტატიაში quirksmode და დოკუმენტაცია Mozilla.

"მკაცრი გამოყენება";

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

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

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

სხვადასხვა ტიპის ციკლები

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

ციკლის სია JavaScript- ში:

• ამისთვის
• ამისთვის ..OF (დაემატა ES6)
• foreach.
• პერიოდი
• გააკეთე

ციკლი ამისთვის

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

(მდგომარეობა 1; მდგომარეობა 2; მდგომარეობა 3) (// თქვენი კოდი)

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

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

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

ციკლი ...

შემდეგია ციკლის ტიპი. მასთან ერთად, თქვენ შეგიძლიათ გაიაროთ კლასის ყველა სფერო.

მოდით მივცეთ მაგალითი.

Var person \u003d (firstname: "Dwayne", lastname: "Charrington", ასაკი: 27, Starsign: "მერწყული"); // ქვემოთ loop გამომავალი: // "Dwayne" // "Charrington" // 27 // "Aquarius" (IF (person.hasownproperty (p)) (console.log (პირი [P]);)

ციკლი ...

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

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

Var Fruits \u003d ["ნარინჯისფერი", "Apple", "Squash", "Pear"]; (ხილის ხილი) (Console.log (ხილი);)

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

Foreach ციკლი

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

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

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

Var Fruits \u003d ["Apple", "ბანანის", "ნარინჯისფერი", "ყურძენი", "მსხალი", "პასიფრუტი"]; / / სამი ღირებულებები Callback ფუნქციურია: // ელემენტი - ელემენტი მიმდინარეობს Traverse // ინდექსი - მიმდინარე ინდექსი ნივთი მასივი დაწყებული 0 // მასივი - მასივი მიმდინარეობს traverse (ალბათ ძირითადად შეუსაბამო) ხილი. Fureach (ფუნქცია (ელემენტი, ინდექსი, მასივი) (Console.log (ინდექსი, ელემენტი););

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

ამ ტიპის ციკლის ერთი ნაკლებობა - ეს არ შეიძლება შეწყდეს. თუ თქვენ უნდა შეიქმნას ციკლი ES5 წესების მიხედვით, მაშინ გამოიყენეთ array.every მეთოდი, გაეცნოს, რომელიც შეგიძლიათ Mozilla დოკუმენტაცია.

ციკლი

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

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

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

Var i \u003d 20; ხოლო (i -) (console.log (i);)

ციკლი გავაკეთოთ ... ხოლო

ასეთი ციკლი საკმაოდ იშვიათია, მაგრამ ის ჯერ კიდევ ღირს, რომ მას გავიგოთ მისი მუშაობა.

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

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

როგორც ყოველთვის, Mozilla- დან დოკუმენტაციაში იპოვით ამ ტიპის ციკლის დეტალურ აღწერას.

ძირითადი მეთოდები და ამოცანები

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

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

მუშაობა სიმები

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

• String.replace (regexp | რა შეცვალოს რა შეცვალოს, Callback) - საშუალებას გაძლევთ შეცვალოთ ნაწილი ხაზი, მას უფლება გამოიყენოს რეგულარული გამონათქვამები.
• String.concat (Storok 1, Line 2 ...) - რამდენიმე ხაზის კავშირი ერთში.
• String.indexof (ღირებულება) - მეთოდი საშუალებას გაძლევთ იპოვოთ ხაზის სასურველი ნაწილის სიმბოლოების თანმიმდევრობა, -1 - თუ სიმებიანი არ არის ნაპოვნი
• String.slice (startindex, endindex) - ბრუნდება სიმებიანი ფართობი startindex to endindex
• String.split (გამყოფი, ლიმიტი) - არღვევს სიმებიანი მასივი მიერ გამყოფი სიმბოლო, მაქსიმალური ლიმიტი სიგრძე.
• String.subsctr (startindex, სიგრძე) - ბრუნდება სტრიქონის ნაწილი startindex ხანგრძლივი სიგრძით.
• String.tolowercase - თარგმნა ყველა სიმებიანი სიმბოლო ქვედა შემთხვევაში
• String.touppercase - გადარიცხვა ყველა სიმებიანი სიმბოლოების ზედა რეესტრში
• String.trim - წაშლის ფართები საწყისი დასაწყისიდან და ბოლოს ხაზი

მუშაობა მასივები

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

• Array.pop არის რეჟისორი უკანასკნელი ელემენტით და ამოიღებს მას მასივიდან.
• Array.shift - დააბრუნებს პირველ ელემენტს და ამოიღებს მას მასივიდან.
• Array.push (val1, val2) - დასძენს ერთი ან მეტი ღირებულებების დასასრულს მასივი. აბრუნებს ახალ მასივის სიგრძეს.
• Array.Reverse - Mirroring ცვლის ბრძანებით ელემენტების მასივი.
• Array.Sort - გაძლევთ საშუალებას დაალაგოთ მასივი საკუთარი ფუნქციის გამოყენებით.
• Array.join (გამყოფი) - აბრუნებს სიმებიანი, რომელიც შედგება მასივი ელემენტებისგან, რომელიც გამოყოფილია გამყოფი სიმბოლოთ (ნაგულისხმევი - მძიმით).
• Array.indexof (ღირებულება) - აბრუნებს მასივის ელემენტის მაჩვენებელს, -1 თუ საქონელი არ არის ნაპოვნი.

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

განსხვავება ზარისა და ვრცელდება

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

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

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

თუ თქვენ უბრალოდ უნდა გადავიტანოთ მასივი, როგორც არგუმენტის მეთოდი, შემდეგ დაწყებული ES6 Advanced (Spread) ოპერატორი. ეს არ იძლევა საშუალებას შეცვალოთ ეს. თქვენ შეგიძლიათ გაეცნოთ მას, როგორც ყოველთვის Mozilla- ს ოფიციალური დოკუმენტაციაში.

ზარის მაგალითი:

ფუნქცია myfunc () (console.log (არგუმენტები);) myfunc.call (ეს, 1, 2, 3, 4, 5);

მაგალითი მაგალითი:

ფუნქცია myfunc () (console.log (არგუმენტები);) myfunc.call (,);

გაცნობა ბიბლიოთეკებთან და ჩარჩოებთან

დღეს, JavaScript- ის ჩარჩოების ყველაზე შესამჩნევი წარმომადგენლები არიან Angularjs, react.js და ember. რა თქმა უნდა, ჯერ კიდევ არსებობს რამდენიმე სხვა.

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

Node.js.

ეჭვი არ არის, რომ node.js უკავია მყარი პოზიცია. პრაქტიკულად ნებისმიერი ფრონტის ბოლო ინსტრუმენტი აგებულია Node.js- ზე და იყენებს NPM (Node Package Manager), თუ ეს უცნობია, მე მტკიცედ ვურჩევ ამ უმოქმედობის გამოსწორებას. მას შემდეგ, რაც node.js იყენებს JavaScript, მაშინ სწავლის იგი არ წარმოადგენს რაიმე განსაკუთრებულ სირთულეებს მათთვის, ვინც უკვე იცნობს ამ ენას. თქვენ მიიღებთ უფრო მეტ დროს, რათა შეიქმნას კოდის პაკეტები, ვიდრე კოდი თავად.

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

არსებობს ჩანგალი node.js მოუწოდა io.js, დღეს ისინი პრაქტიკულად ანალოგები, და ბოლოს თქვენ უბრალოდ დაწერეთ JavaScript გარდა მცირე განსხვავებები.

ტესტირება

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

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

ინსტრუქციები

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

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

აქ არის კომპლექტი ინსტრუმენტები, რომ თქვენ უნდა გვახსოვდეს: gulp, webpack და babeljs. არსებობს ბევრად მეტი ინსტრუმენტი, მაგრამ ინსტრუმენტები, როგორიცაა Gulp და Grunt დაგეხმარებათ განვითარება და მართვა JavaScript განაცხადების.

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

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

JavaScript Tools Go Hand ხელში, როდესაც განვითარებადი Isomorphic JavaScript (კოდი გამოიყენება როგორც კლიენტთა მხარეს და სერვერზე). Ecmascript 6, ის არის ES6, ის არის ESNext

ბრაუზერები ჯერ კიდევ უნდა განხორციელდეს Ecmascript ფუნქციური უმეტესი ნაწილი 6. მაგრამ დღეს შეგიძლიათ გამოიყენოთ ახალი ელემენტი ES6- დან JavaScript Compilers- ის გამოყენებით. გაეცანით ახალ API- ებს და მეთოდებს: რიგები, მასივები და სხვა მეთოდები, როგორიცაა სუსტი, სიმბოლოები და კლასები. თქვენ ყოველთვის უნდა იცოდეთ მომავალი ცვლილებების შესახებ.

დასკვნა

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