TypeScript Tutorial: Alamin ang Tungkol sa Mga Batayan ng TypeScript

Ang TypeScript ay isang malakas na nai-type na superset ng na tumutukoy sa simpleng JavaScript. Maaari mong gamitin ang wikang ito para sa pagbuo ng scale ng application na JavaScript. Gayundin, maaari itong maipatupad sa anumang browser, anumang host, at anumang Operating System. Sa TypeScript Tutorial na ito, papasok kami sa lalim ng TypeScript at mauunawaan ang mga pangunahing kaalaman sa sumusunod na pagkakasunud-sunod:

• Panimula sa TypeScript
• Mga Uri ng TypeScript
• Mga variable
• Mga Operator
• Mga loop
• Mga pagpapaandar
• Mga kuwerdas
• Mga array
• Mga interface
• Mga klase
• Mga Bagay
• Kaso ng Paggamit ng TypeScript

Panimula sa TypeScript

Ang TypeScript ay isang nai-type na superset ng JavaScript na tumutukoy sa simpleng JavaScript. Ang TypeScript ay puro object-oriented sa mga klase, interface at statically type na mga wika ng programa tulad ng C # o . Nangangailangan ito ng isang tagatala upang mag-ipon at bumuo sa JavaScript file. Talaga, ang TypeScript ay ang bersyon na ES6 ng JavaScript na may ilang mga karagdagang tampok.

Ang isang code ng TypeScript ay nakasulat sa isang file na may .ts extension at pagkatapos ay naipon sa JavaScript gamit ang tagatala. Maaari mong isulat ang file sa anumang code editor at kailangang mai-install ang tagatala sa iyong platform. Pagkatapos ng pag-install, ang utos tsc .ts naiipon ang TypeScript code sa isang payak na file na JavaScript.

Syntax:

var message: string = 'Maligayang pagdating sa Edureka!' console.log (mensahe)

Sa pag-iipon, bumubuo ito ng sumusunod na JavaScript code:

// Nabuo sa pamamagitan ng typcript 1.8.10 var message = 'Maligayang Pagdating sa Edureka!' console.log (mensahe)

Mga Tampok ng TypeScript

• Cross-Platform: Maaaring mai-install ang tagatala ng TypeScript sa anumang Operating System tulad ng Windows, MacOS at Linux.

  
  
  

• Wika na Nauugnay sa Bagay : Nagbibigay ang TypeScript ng mga tampok tulad ng Mga klase , Mga interface, at Modyul. Kaya, maaari itong sumulat ng code na nakatuon sa object para sa client-side pati na rin ang pag-unlad ng server-side.

• Static na pag-check-type : Gumagamit ang TypeScript ng static na pagta-type at tumutulong na i-type ang pag-check sa oras ng pag-ipon. Kaya, maaari kang makahanap ng mga error habang sinusulat ang code nang hindi pinapatakbo ang script.

• Opsyonal na Static na Pagta-type : Pinapayagan din ng TypeScript ang opsyonal na static na pagta-type sakaling gumagamit ka ng pabagu-bagong pagta-type ng JavaScript.

• Pagmanipula ng DOM : Maaari mong gamitin ang TypeScript upang manipulahin ang DOM para sa pagdaragdag o pag-aalis ng mga elemento.

• Mga Tampok ng ES 6 : Kasama sa TypeScript ang karamihan sa mga tampok ng nakaplanong ECMAScript 2015 (ES 6, 7) tulad ng klase, interface, mga arrow function, atbp.

Mga kalamangan sa Paggamit ng TypeScript

• Ang TypeScript ay mabilis, simple, madaling malaman at tumatakbo sa anumang browser o JavaScript engine.

• Ito ay katulad sa JavaScript at gumagamit ng parehong syntax at semantics.

• Nakakatulong ito sa mga backend developer na magsulat ng pang-harap mas mabilis ang code .

• Maaaring tawagan ang typeScript code mula sa isang mayroon nang JavaScript code . Gayundin, gumagana ito sa mga mayroon nang mga balangkas at aklatan ng JavaScript nang walang anumang mga isyu.

• Ang Definition file, na may extension na .d.ts, ay nagbibigay ng suporta para sa umiiral na mga library ng JavaScript tulad ng Jquery, D3.js , atbp. Kaya, maaaring magdagdag ng TypeScript code Mga aklatan ng JavaScript gamit ang mga kahulugan ng uri upang magamit ang mga benepisyo ng pag-check sa uri, autocompletion ng code, at dokumentasyon sa mga umiiral nang na-type na library na JavaScript.

• May kasama itong mga tampok mula sa ES6 at ES7 na maaaring tumakbo sa ES5-level na mga JavaScript engine tulad ng Node.js .

Ngayon na naintindihan mo kung ano ang TypeScript, magpatuloy tayo sa TypeScript Tutorial na ito at tingnan ang iba't ibang mga uri.

Mga Uri ng TypeScript

Kinakatawan ng Type System ang iba't ibang uri ng mga halagang sinusuportahan ng wika. Sinusuri nito ang pagiging wasto ng ipinagkakaloob halaga bago sila maiimbak o manipulahin ng programa.

Maaari itong mauri sa dalawang uri tulad ng:

• Built-in : Kasama rito ang numero, string, boolean, void, null at hindi natukoy.
• Tinukoy ng gumagamit : Kasama rito ang Mga Enumerasyon (enum), klase, interface, array, at tuple.

Ngayon, magpatuloy tayo sa TypeScript Tutorial na ito at maunawaan ang higit pa tungkol sa mga variable.

TypeScript Tutorial: Mga variable

Ang variable ay isang pinangalanang puwang sa memorya na ginagamit upang mag-imbak ng mga halaga.

Ang uri ng syntax para sa pagdedeklara ng isang variable sa TypeScript ay may kasamang isang colon (:) pagkatapos ng variable na pangalan, na sinusundan ng uri nito. Katulad ng JavaScript, ginagamit namin ang var keyword upang ideklara ang isang variable.

Mayroong apat na pagpipilian kapag idineklara namin ang isang variable:

var [identifier]: [type-anotation] = halaga

var [identifier]: [type-anotation]

var [identifier] = halaga

var [kilalanin]

Halimbawa:

var name: string = 'Daisy' var empid: number = 1001 console.log ('name' + name) console.log ('empleyado id' + empid)

Sa pag-iipon, bubuo ito ng sumusunod na JavaScript code:

// Nabuo sa pamamagitan ng typescript 1.8.10 var name = 'Daisy' var empid = 1001 console.log ('name' + name) console.log ('employee id:' + empid)

Output:

pangalan: Daisy
empleyado id: 1001

Ngayon, magpatuloy tayo sa susunod na paksa ng aming TypeScript Tutorial.

Mga Operator

Ginagamit ang isang operator upang tukuyin ang mga pagpapaandar na isasagawa sa data. Ang data kung saan gumagana ang mga operator ay tinatawag na operand. Mayroong iba't ibang mga uri ng mga operator sa TypeScript tulad ng:

• Mga operator ng arithmetic
• Mga lohikal na operator
• Mga kaugnay na operator
• Bitwise operator
• Mga operator ng pagtatalaga

Mga Operator ng Arithmetic

Halimbawa:

var num1: number = 10 var num2: number = 2 var res: number = 0 res = num1 + num2 console.log ('Sum:' + res) res = num1 - num2 console.log ('Pagkakaiba:' + res) res = num1 * num2 console.log ('Produkto:' + res)

Output:

Kabuuan: 12
Pagkakaiba: 8
Produkto: 20

Mga Lohikal na Operator

Halimbawa:

var avg: number = 20 var porsyento: number = 90 console.log ('Value of avg:' + avg + ', halaga ng porsyento:' + porsyento) var res: boolean = ((avg> 50) && (porsyento> 80 )) console.log ('(avg> 50) && (porsyento> 80):', res)

Output:

Halaga ng avg: 20, halaga ng porsyento: 90
(avg> 50) && (porsyento> 80): hindi totoo

Mga kaugnay na Operator

Halimbawa:

var num1: number = 10 var num2: number = 7 console.log ('Halaga ng num1:' + num1) console.log ('Halaga ng num2:' + num2) var res = num1> num2 console.log ('num1 mas malaki kaysa sa num2: '+ res) res = num1
 Output: 
Halaga ng num1: 10 
 Halaga ng num2: 7 
 num1 mas malaki kaysa sa num2: totoo 
 num1 mas mababa kaysa sa num2: false
 Mga Bitwise Operator 
 Mga Operator 
 Paglalarawan 
 Bitwise AT (&) 
gumaganap ng isang pagpapatakbo ng Boolean AT sa bawat piraso ng mga argumento ng integer.
 Bitwise O (|) 
Gumagawa ito ng isang pagpapatakbo ng Boolean O sa bawat piraso ng mga argumento sa integer.
 Bitwise XOR (^) 
Gumagawa ito ng isang eksklusibong operasyon ng Boolean O operasyon sa bawat piraso ng mga argumento sa integer.
 Bitwise HINDI (~) 
Ito ay isang unary operator at nagpapatakbo sa pamamagitan ng pag-reverse ng lahat ng mga piraso sa operand.
 Kaliwa shift (<<) 
Inililipat nito ang lahat ng mga piraso sa unang operand nito sa kaliwa ng bilang ng mga lugar na tinukoy sa ikalawang operand.
 Tamang Paglipat (>>) 
Ang halaga ng kaliwang operand ay inililipat pakanan ng bilang ng mga piraso na tinukoy ng tamang operand.
 Tamang Paglipat gamit ang Zero (>>>) 
Ito ay katulad sa >> operator, maliban na ang mga piraso na inilipat sa kaliwa ay palaging zero.
 Halimbawa: 
var a: number = 2 // Bit presentasyon 10 var b: number = 3 // Bit presentasyon 11 var resulta ng resulta = (a & b) console.log ('(a & b) =>', resulta) resulta = ( a | b) console.log ('(a | b) =>', resulta)
 Output: 
(a & b) => 2 
 (a | b) => 3
 Mga Operator ng Asignatura 
 Mga Operator 
 Paglalarawan 
 Simpleng Takdang-Aralin (=) 
Nagtatalaga ng mga halaga mula sa kanang bahagi ng operand hanggang sa kaliwang bahagi ng operand
 Idagdag at takdang-aralin (+ =) 
Nagdaragdag ito ng tamang operan sa kaliwang operand at itinalaga ang resulta sa kaliwang operand.
 Ibawas at takdang-aralin (- =) 
Binabawas nito ang tamang operan mula sa kaliwang operand at itinatalaga ang resulta sa kaliwang operand.
 I-multiply at takdang-aralin (* =) 
Pinararami nito ang kanang operan ng kaliwang operand at itinatalaga ang resulta sa kaliwang operand.
 Hatiin at takdang aralin (/ =) 
Hinahati nito ang kaliwang operand sa kanang operan at itinatalaga ang resulta sa kaliwang operand.
 Halimbawa: 
var a: number = 12 var b: number = 10 a = b console.log ('a = b:' + a) a + = b console.log ('a + = b:' + a) a - = b console .log ('a- = b:' + a)
 Output: 
a = b: 10 
 a + = b: 20 
 a - = b: 10
Ito ang iba`t ibang mga operator. Ngayon ay magpatuloy tayo sa aming TypeScript Tutorial at alamin ang tungkol sa mga loop.
 Mga loop 
Maaaring may mga sitwasyon kung kailan kailangang maisagawa ang isang bloke ng code ng maraming beses. A loop Pinapayagan kami ng pahayag na magpatupad ng isang pahayag o pangkat ng mga pahayag ng maraming beses.
Ang mga loop ng TypeScript ay maaaring maiuri bilang:
 Para sa Loop 
Ang para sa loop ay isang pagpapatupad ng isang tiyak na loop.
 Syntax: 
para sa (unang ekspresyon pangalawang ekspresyon pangatlong ekspresyon) {// mga pahayag na naisakatuparan nang paulit-ulit}
Dito, ang unang expression ay naisakatuparan bago magsimula ang loop. Ang pangalawang expression ay ang kundisyon para sa loop upang maisagawa. At ang pangatlong expression ay naisakatuparan pagkatapos ng pagpapatupad ng bawat code block.
 Halimbawa: 
para sa (hayaan ang = 0 i<2 i++) { console.log ('Execute block statement' + i) }
 Output: 
Isagawa ang pahayag ng block 0 
Isagawa ang pahayag ng block 1
 Habang Loop 
Ang habang loop ay nagpapatupad ng mga tagubilin sa bawat oras na tinukoy ng kundisyon na sinusuri sa totoo.
 Syntax: 
habang (kondisyon expression) {// code block na naisakatuparan}
 Halimbawa: 
hayaan ang: numero = 1 habang (i<3) { console.log( 'Block statement execution no.' + i ) i++ }
 Output: 
I-block ang pagpapatupad ng pahayag no.1 
I-block ang pagpapatupad ng blg.2
 Gawin..Habang Loop 
Ang do & helliparily loop ay katulad ng habang loop maliban na hindi nito susuriin ang kundisyon sa kauna-unahang pagkakataon na gumaganap ang loop.
 Syntax: 
gawin ang {// code block upang maipatupad} habang (kondisyon expression)
 Halimbawa: 
  
hayaan ang: number = 1 gawin ang {console.log ('I-block ang pagpapatupad ng no.' + i) i ++} habang (i<3)
 Output: 
I-block ang pagpapatupad ng pahayag no.1 
I-block ang pagpapatupad ng blg.2
Bukod sa mga ito, nariyan ang pahinga at ipagpatuloy ang mga pahayag sa TypeScript na ginagamit sa isang loop.
 Break Statement 
Ginagamit ang pahayag ng pahinga upang makontrol ang isang konstruksyon. Ang paggamit ng pahayag ng pahinga sa isang loop ay tumutulong sa programa sa paglabas ng loop.
 Halimbawa: 
var i: number = 1 habang (i<=10) { if (i % 5 == 0) { console.log ('The first multiple of 5 between 1 and 10 is : '+i) break //exit the loop if the first multiple is found } i++ } //outputs 5 and exits the loop
 Output: 
Ang unang maramihang 5 sa pagitan ng 1 at 10 ay: 5
 Magpatuloy sa Pahayag 
Nilaktawan ng pagpapatuloy na pahayag ang mga kasunod na pahayag sa kasalukuyang pag-ulit at binabalik ang kontrol sa simula ng loop.
 Halimbawa: 
var num: number = 0 var count: number = 0 para sa (num = 0num<=10num++) { if (num % 2==0) { continue } count++ } console.log (' The count of odd values between 0 and 10 is: '+count)
 Output: 
Ang bilang ng mga kakatwang halaga sa pagitan ng 0 at 10 ay: 5
Ito ang magkakaibang mga loop sa TypeScript. Ngayon, magpatuloy tayo sa aming TypeScript Tutorial at maunawaan ang mga pagpapaandar.
 Mga pagpapaandar 
Sa JavaScript, pagpapaandar ay isa sa pinakamahalagang bahagi dahil ito ay isang functional na wika ng programa. Tinitiyak ng mga pagpapaandar na ang programa ay mapanatili at magagamit muli, at nakaayos sa nababasa na mga bloke. Habang ang TypeScript ay nagbibigay ng konsepto ng mga klase at modyul, ang mga pagpapaandar pa rin ay isang mahalagang bahagi ng wika.
 Pinangalanang Mga Pag-andar 
Ang isang pinangalanang pagpapaandar ay ginagamit upang ideklara at tumawag sa isang pagpapaandar sa pamamagitan ng ibinigay na pangalan.
 Halimbawa: 
display display () {console.log ('TypeScript Function')} display ()
 Output: 
TypeScript Function
 Anonymous na Pag-andar 
Ang isang hindi nagpapakilalang pagpapaandar ay isa na tinukoy bilang isang expression. Ang expression na ito ay nakaimbak sa isang variable. Ang mga pagpapaandar na ito ay tinawag gamit ang variable na pangalan kung saan nakaimbak ang pagpapaandar.
 Halimbawa: 
hayaan ang pagbati = pagpapaandar () {console.log ('TypeScript Function')} pagbati ()
 Output: 
TypeScript Function
 Pag-andar ng Arrow 
Ginagamit ang mga notasyong taba ng arrow para sa mga hindi nagpapakilalang pag-andar ibig sabihin para sa mga expression ng pag-andar. Tinatawag din silang lambda function sa ibang mga wika.
 Syntax: 
(param1, param2, ..., paramN) => expression
Ang paggamit ng fat arrow (=>) ay bumababa ng pangangailangan na gamitin ang keyword na ‘function’. Ang mga parameter ay ipinapasa sa mga angular bracket, at ang expression ng pag-andar ay nakapaloob sa loob ng mga kulot na bracket {}.
 Halimbawa: 
let sum = (x: number, y: number): number => {return x + y} kabuuan (10, 30) // nagbabalik 40
 Pag-o-overload ng pagpapaandar 
Nagbibigay ang TypeScript ng konsepto ng overloading ng pag-andar. Kaya, maaari kang magkaroon ng maraming mga pagpapaandar na may parehong pangalan ngunit magkakaibang mga uri ng parameter at uri ng pagbabalik.
isa at hasa relasyon sa java
 Halimbawa: 
function add (a: string, b: string): string function add (a: number, b: number): number return a + b} add ('Hello', 'Edureka') // Return 'Hello Edureka' add ( 10, 10) // nagbabalik 20
Sa halimbawa sa itaas, mayroon kaming parehong pag-andar na idagdag () na may dalawang mga deklarasyon ng pag-andar at isang pagpapatupad ng pag-andar. Ang unang pirma ay may dalawang mga parameter ng uri ng string, samantalang ang pangalawang lagda ay may dalawang mga parameter ng uri ng uri.
Ito ang magkakaibang uri ng pag-andar. Ngayon, magpatuloy tayo sa aming TypeScript Tutorial at maunawaan ang mga string sa TypeScript.
 TypeScript Tutorial: Mga string 
Ang  ay isa pang primitive na uri ng data na ginagamit upang mag-imbak ng data ng teksto. Ang mga halaga ng string ay napapaligiran ng solong mga marka ng panipi o dobleng mga panipi.
 Syntax: 
var var_name = bagong String (string)
Mayroong iba't ibang mga katangian ng mga pamamaraan na magagamit sa String object tulad ng:
 Tagabuo - Nagbabalik ito ng isang sanggunian sa pag-andar ng String na lumikha ng object
 Haba - Ibinabalik nito ang haba ng string
 Prototype - Pinapayagan ka ng pag-aari na ito na magdagdag ng mga pag-aari at pamamaraan sa isang bagay
 Halimbawa: 
hayaan ang pangalan = bagong String ('Maligayang Pagdating sa Edureka!') console.log ('Mensahe:' + pangalan) console.log ('Haba:' + pangalan. haba)
 Output: 
Mensahe: Maligayang pagdating sa Edureka! 
 Haba: 19
 Mga Paraan ng String 
Ang Listahan ng Mga Paraan sa String Object ay may kasamang:
 Pamamaraan 
 Paglalarawan 
 charAt () 
Ibinabalik nito ang character sa tinukoy na index
 charCodeAt () 
Nagbabalik ito ng isang numero na nagpapahiwatig ng halaga ng Unicode ng character sa ibinigay na index
 concat () 
Pinagsasama ang teksto ng dalawang mga string at nagbabalik ng isang bagong string
 indexOf () 
Ibinabalik ang index sa loob ng pagtawag sa bagay ng String ng unang paglitaw ng tinukoy na halaga
 lastIndexOf () 
Ibinabalik nito ang index sa loob ng bagay ng pagtawag sa String ng huling paglitaw ng tinukoy na halaga
 tugma () 
Ginamit upang tumugma sa isang regular na expression laban sa isang string
 localeCompare () 
Nagbabalik ng isang numero na nagpapahiwatig kung ang isang sanggunian na string ay dumating bago o pagkatapos o pareho sa ibinigay na string sa pagkakasunud-sunod ng pagkakasunud-sunod
 maghanap () 
Isinasagawa nito ang paghahanap para sa isang tugma sa pagitan ng isang regular na expression at isang tinukoy na string
 palitan () 
Ginamit upang makahanap ng isang tugma sa pagitan ng isang regular na expression at isang string, at upang mapalitan ang naitugmang substring ng isang bagong substring
 hiwa () 
Kinukuha nito ang isang seksyon ng isang string at nagbabalik ng isang bagong string
 hatiin () 
Hinahati ang isang bagay ng String sa isang hanay ng mga string sa pamamagitan ng paghihiwalay ng string sa mga substring
 substr () 
Ibinabalik ang mga character sa isang string na nagsisimula sa tinukoy na lokasyon sa pamamagitan ng tinukoy na bilang ng mga character
 substring () 
Ibinabalik nito ang mga character sa isang string sa pagitan ng dalawang index sa string
 toLocaleLowerCase () 
Ang mga character sa loob ng isang string ay na-convert sa mas mababang kaso habang iginagalang ang kasalukuyang lokal
 toLocaleUpperCase () 
Ang mga character sa loob ng isang string ay na-convert sa itaas na kaso habang iginagalang ang kasalukuyang lokal
 toLowerCase () 
Ibinabalik nito ang halaga ng string ng pagtawag na na-convert sa mas mababang kaso
 toUpperCase () 
Ibinabalik nito ang halaga ng string ng pagtawag na na-convert sa uppercase
 toString () 
Nagbabalik ng isang string na kumakatawan sa tinukoy na bagay
 halagaOf () 
Ibinabalik ang primitive na halaga ng tinukoy na bagay
 Halimbawa: 
let str: string = 'Maligayang pagdating sa Edureka' str.charAt (0) // nagbabalik 'w' str.charAt (2) // nagbabalik 'l' 'Maligayang pagdating sa Edureka'. : string = 'welcome' let str2: string = 'Edureka' str1.concat (str2) // Return 'welcomeEdureka' str1.concat (', str2) // Return 'welcome Edureka' str1.concat (' to ' ') // nagbabalik' maligayang pagdating sa '
Ngayong alam mo na ang tungkol sa mga string, magpatuloy tayo sa tutorial na ito ng TypeScript at maunawaan ang mga array.
 Mga array sa TypeScript 
Isang array ay isang espesyal na uri ng uri ng data na nag-iimbak ng maraming halaga ng iba't ibang mga uri ng data nang sunud-sunod gamit ang isang espesyal na syntax. Ang mga elemento ng Array ay kinilala ng isang natatanging integer na tinatawag na subscript o index ng elemento.
 Syntax: 
var array_name [: datatype] // deklarasyon array_name = [val1, val2, valn ..] // initialization
 Halimbawa: 
hayaan ang mga pangalan: Array names = ['John', 'Daisy', 'Rachel'] let ids: Array ids = [101, 700, 321]
 Mga Paraan ng Array 
Narito ang isang listahan ng iba't ibang mga pamamaraan ng Array na maaaring magamit para sa iba't ibang mga layunin:
 Pamamaraan 
 Paglalarawan 
 filter () 
Lumilikha ng isang bagong array kasama ang lahat ng mga elemento ng array na ito kung saan ang ibinigay na pagpapaandar ng pag-filter ay bumalik totoo
 bawat() 
Nagbalik totoo kung ang bawat elemento sa array na ito ay nasiyahan ang ibinigay na pagpapaandar ng pagsubok
 concat () 
Nagbabalik ng isang bagong array na binubuo ng array na ito na sumali sa iba pang mga arrays
 indexOf () 
Ibinabalik ang una o hindi bababa sa index ng isang elemento sa loob ng array na katumbas ng tinukoy na halaga
 para sa bawat () 
Tumatawag ng isang pagpapaandar para sa bawat elemento sa array
 sumali () 
Sumali sa lahat ng mga elemento ng isang array sa isang string
 lastIndexOf () 
Ibinabalik ang huli o pinakadakilang index ng isang elemento sa loob ng array na katumbas ng tinukoy na halaga
 mapa () 
Lumilikha ng isang bagong array na may mga resulta ng pagtawag ng isang ibinigay na pag-andar sa bawat elemento sa array na ito
 itulak () 
Nagdaragdag ng isa o higit pang mga elemento sa dulo ng isang array at ibinabalik ang bagong haba ng array
 pop () 
Tinatanggal ang huling elemento mula sa isang array at ibabalik ang sangkap na iyon
 bawasan () 
Mag-apply ng isang function nang sabay-sabay laban sa dalawang mga halaga ng array mula kaliwa hanggang kanan upang mabawasan ito sa isang solong halaga
 bawasan ang Karapatan () 
Mag-apply ng isang function nang sabay-sabay laban sa dalawang mga halaga ng array mula pakanan hanggang kaliwa upang mabawasan ito sa isang solong halaga
 baligtarin () 
Baliktad sa pagkakasunud-sunod ng mga elemento ng isang array
 shift () 
Tinatanggal ang unang elemento mula sa isang array at ibabalik ang sangkap na iyon
 hiwa () 
Kinukuha ang isang seksyon ng isang array at nagbabalik ng isang bagong array
 ilang () 
Bumabalik ito ng totoo kung hindi bababa sa isang elemento sa array na ito ang nagbibigay ng kasiyahan sa ibinigay na pagpapaandar ng pagsubok
 pag-uri-uriin () 
Pinagsasama nito ang mga elemento ng isang array
 toString () 
Nagbabalik ng isang string na kumakatawan sa array at mga elemento nito
 splice () 
Nagdaragdag ito at / o tinatanggal ang mga elemento mula sa isang array
 hindi mabilis () 
Nagdaragdag ng isa o higit pang mga elemento sa harap ng isang array at ibinabalik ang bagong haba ng array
 Halimbawa: 
pangalan ng var: Array = ['John', 'Daisy', 'Tara'] name.sort () console.log (name) // output: ['Daisy', 'John', 'Tara'] console.log ( name.pop ()) // output: Tara name.push ('Rachel') console.log (name) // output: ['John', 'Daisy', 'Rachel']
Sumulong muna tayo sa Tutorial na TypeScript na ito at alamin ang tungkol sa Mga Interface.
 Mga TypeScript Interface 
Ang interface ay isang istraktura na tumutukoy sa kontrata sa iyong aplikasyon. Tinutukoy nito ang syntax para sa mga susunod na klase. Naglalaman lamang ito ng deklarasyon ng mga miyembro at responsibilidad ng nagmula sa klase na tukuyin ang mga miyembro.
 Halimbawa: 
interface empleyado {empID: number empName: string getSalary: (number) => number // arrow function getManagerName (number): string}
Sa halimbawa sa itaas, ang Empleado Ang interface ay may kasamang dalawang mga pag-aari empID at empName . May kasama rin itong pagdedeklara ng pamamaraan getSalaray gamit ang isang pagpapaandar ng arrow na nagsasama ng isang parameter ng numero at isang uri ng pagbabalik ng numero. Ang getManagerName ang pamamaraan ay idineklara gamit ang isang normal na pag-andar.
 TypeScript  Mga klase 
Ipinakilala ng TypeScript ang mga klase upang magamit nila ang mga pakinabang ng mga diskarte na nakatuon sa object tulad ng encapsulation at abstraction. Ang klase sa TypeScript ay pinagsama-sama sa mga simpleng pag-andar ng JavaScript ng tagaipon ng TypeScript upang gumana sa mga platform at browser.
Kasama sa isang klase ang sumusunod:
 Tagabuo 
 Ari-arian 
 Paraan 
 Halimbawa: 
klase ng Empleyado {empID: number empName: string konstruktor (ID: number, name: string) {this.empName = name this.empID = ID} getSalary (): number {return 40000}}
 Mana 
Sinusuportahan ng TypeScript Mana dahil ito ay ang kakayahan ng isang programa upang lumikha ng mga bagong klase mula sa isang mayroon nang klase. Ang klase na pinalawig upang lumikha ng mas bagong mga klase ay tinatawag na magulang na klase o sobrang klase. Ang mga bagong nilikha na klase ay tinatawag na bata o mga sub na klase.
Nagmamana ang isang klase mula sa isa pang klase gamit ang keyword na 'nagpapalawak'. Ang mga klase ng bata ay nagmamana ng lahat ng mga pag-aari at pamamaraan maliban sa mga pribadong miyembro at tagapagbuo mula sa magulang na klase. Ngunit, hindi sinusuportahan ng TypeScript ang maraming mana.
 Syntax: 
ang class child_class_name ay nagpapalawak ng parent_class_name
 Halimbawa: 
klase ng Tao {pangalan: string konstruktor (pangalan: string) {this.name = name}} nagpapalawak ang empleyado ng Taong {empID: number konstruktor (empID: number, name: string) {super (name) this.empID = empid} displayName (): walang bisa {console.log ('Pangalan =' + this.name + ', ID ng empleyado =' + this.empID)}} hayaan ang emp = bagong empleyado (701, 'Jason') emp.displayName () // Pangalan = Jason, ID ng empleyado = 701
Ngayong alam mo na ang tungkol sa mga klase, magpatuloy tayo sa TypeScript Tutorial na ito at alamin ang tungkol sa Mga Bagay.
 Mga Bagay sa TypeScript 
Ang isang bagay ay isang halimbawa na naglalaman ng iba't ibang hanay ng mga pares ng key-halaga. Ang mga halaga ay maaaring mga halaga ng scalar o pag-andar o kahit na isang hanay ng iba pang mga bagay.
 Syntax: 
var object_name = {key1: “value1”, // scalar value key2: “value”, key3: function () {// functions}, key4: [“content1”, “content2”]
Ang isang bagay ay maaaring maglaman ng mga halaga ng scalar, pag-andar at istraktura tulad ng mga array at tuple.
 Halimbawa: 
var person = {firstname: 'Danny', apelyido: 'Green'} // i-access ang mga halaga ng object console.log (person.firstname) console.log (person.lastname)
Sa pag-iipon, bubuo ito ng parehong code sa JavaScript.
 Output: 
Danny 
 Berde
Ito ang magkakaibang mahalagang elemento ng TypeScript. Ngayon, magpatuloy tayo sa TypeScript Tutorial na ito at tingnan ang isang halimbawa upang maunawaan ang kaso ng paggamit.
 TypeScript Tutorial: Gumamit ng Kaso 
Dito, matututunan natin kung paano mag-convert ng mayroon nang  sa TypeScript.
Kapag nag-ipon kami ng isang TypeScript file, gumagawa ito ng kaukulang JavaScript file na may parehong pangalan. Dito, kailangan naming siguraduhin na ang aming orihinal na file na JavaScript na kumikilos bilang pag-input ay hindi maaaring nasa parehong direktoryo upang hindi ma-override ng TypeScript ang mga ito.
Ang proseso upang lumipat mula sa JavaScript patungong TypeScript ay nagsasama ng mga sumusunod na hakbang:
 1. Magdagdag ng tsconfig.json file sa proyekto 
Kailangan mong magdagdag ng isang tsconfig.json file sa proyekto. Gumagamit ang TypeScript ng isang tsconfig.json file para sa pamamahala ng mga pagpipilian sa pagtitipon ng proyekto, tulad ng kung aling mga file ang nais mong isama at ibukod.
{'compilerOptions': {'outDir': './built', 'allowJs': true, 'target': 'es5'}, 'isama': ['./src/#/*']}
 2. Isama sa isang build tool 
Karamihan sa mga proyekto ng JavaScript ay mayroong isang integrated tool na build tulad ng gulp o webpack. Maaari mong isama ang mga proyekto sa webpack sa mga sumusunod na paraan:
Patakbuhin ang sumusunod na utos sa terminal:
$ npm i-install ang nakakamangha-typecript-loader source-map-loader
Sa pagsasama ng webpack, gumagamit ka ng mga kahanga-hangang-typcript-loader na sinamahan ng source-map-loader para sa mas madaling pag-debug ng source code.
Pangalawa, pagsamahin ang pag-aari ng module na module sa aming webpack.config.js file upang isama ang mga loader.
 3. Ilipat ang lahat ng mga .js file sa .ts file 
Sa hakbang na ito, kailangan mong palitan ang pangalan ng .js file sa .ts file. Katulad nito, kung gumagamit ang file ng JSX, kakailanganin mong palitan ang pangalan nito sa .tsx. Ngayon, kung buksan namin ang file na iyon sa isang editor na sumusuporta sa TypeScript, ang ilan sa mga code ay maaaring magsimulang magbigay ng mga error sa pagtitipon. Kaya, ang pag-convert ng mga file nang paisa-isa ay nagbibigay-daan sa paghawak ng mga error sa pagsasama-sama nang mas madali. Kung nakakita ang TypeScript ng anumang mga error sa pag-ipon sa panahon ng pag-convert, nagawa pa rin nitong isalin ang code.
 4. Suriin kung may mga error 
Matapos ilipat ang js file sa ts file, kaagad, sisimulan ng TypeScript ang Type Checking ng aming code. Kaya, maaari kang makakuha ng mga error sa diagnostic sa JavaScript code.
 5. Gumamit ng third party na JavaScript Library 
Gumagamit ang mga proyekto ng JavaScript ng mga library ng third-party tulad ng  o si Lodash. Upang makapag-ipon ng mga file, kailangang malaman ng TypeScript ang mga uri ng lahat ng mga bagay sa mga libraryong ito. Ang mga file ng kahulugan ng TypeScript na uri para sa mga aklatan ng JavaScript ay magagamit na sa DefinitiveTyped. Kaya, hindi na kailangang i-install ang ganitong uri sa labas. Kailangan mo lamang i-install ang mga uri na ginagamit sa aming proyekto.
Para sa jQuery, maaari mong mai-install ang kahulugan:
$ npm i-install ang @ mga uri / jquery
Pagkatapos nito, gawin ang mga pagbabago sa proyekto ng JavaScript, patakbuhin ang tool na bumuo. Ngayon, dapat ay mayroon kang proyekto ng TypeScript na naipon sa simpleng JavaScript na maaaring patakbuhin sa browser.
Sa pamamagitan nito, nakarating kami sa pagtatapos ng TypeScript Tutorial na ito. Inaasahan kong naunawaan mo ang lahat ng mahahalagang elemento ng TypeScript.
 Suriin ang     ni Edureka.  Tutulungan ka ng Pagsasanay sa Pagpapatunay sa Pag-unlad ng Web na Alamin kung paano lumikha ng mga kahanga-hangang website gamit ang HTML5, CSS3, Twitter Bootstrap 3, jQuery at Google API at i-deploy ito sa Amazon Simple Storage Service (S3). 
 May tanong ba sa amin? Mangyaring banggitin ito sa seksyon ng mga komento ng 'TypeScript Tutorial' at babalikan ka namin.