Jump to content

Bebe

Developer
  • Content count

    84
  • Joined

  • Last visited

  • Days Won

    6
  1. Scrierea scripturilor C ++ Scriptul C ++ este un dialect specific al limbajului de programare C ++ susținut de TestComplete. Se bazează pe JScript. Acesta a fost special conceput pentru a permite dezvoltatorilor C ++ să porteze cu ușurință rutinele de script la aplicațiile lor de auto-testare și conectare C ++ . Aplicațiile conectate și auto-testare sunt depășite. Nu vă recomandăm să le folosiți. TestComplete poate înregistra și reda rutine C ++ Script. Adică puteți înregistra un script în TestComplete, debug-l acolo, apoi importați acest script în aplicația dvs. C ++ și faceți-l să funcționeze adăugând doar câteva rânduri. De exemplu: // Acest cod a fost înregistrat de TestComplete: funcție Test () { var p, w; p = Sys ["Proces"] ("notepad"); w = p ["Window"] ("Notepad", "*"); w [ "Activare"] (); w ["Window"] ("Edit") ["VScroll"] ["Pos"] = 0; w ["Fereastră"] ("Editare") ["Faceți clic"] (9, 9); Sys [ "Keys"] ( "Test"); w [ "MainMenu"] [ "clic pe "] ( "File | Exit"); } // Acest cod a fost importat într-o aplicație conectată C ++: #include "c: \ TestComplete \ Aplicații conectate \ C ++ \ script.h" folosind spațiul de nume TestComplete; Funcție IMPLEMENT_TESTCOMPLETE_GLOBAL_OBJECTS Test () { var p, w; p = Sys ["Proces"] ("notepad"); w = p ["Window"] ("Notepad", "*"); w [ "Activare"] (); w ["Window"] ("Edit") ["VScroll"] ["Pos"] = 0; w ["Fereastră"] ("Editare") ["Faceți clic"] (9, 9); Sys [ "Keys"] ( "Test"); w [ "MainMenu"] [ "clic pe "] ( "File | Exit"); } Limba codului înregistrat de TestComplete pentru proiectele dvs. C ++ este JScript. Deci, puteți scrie pur și simplu orice este permis în JScript și acest script va fi operațional. De exemplu, în scriptul JScript și C ++ toate variabilele și constantele sunt VARIANT. Trebuie să le declarați și ar trebui să faceți acest lucru folosind următorul format: var p, w; Sintaxa scripturilor C ++ este aceeași cu sintaxa scripturilor C # (deoarece C # Script se bazează și pe JScript). Acestea sunt aceleași atâta timp cât scripturile se află în TestComplete. Dacă exportați scripturi într-o aplicație conectată, acestea vor fi diferite. Adică, sintaxa rutinelor C ++ Script și C # Script exportate către aplicațiile C ++ și C # Conectate și auto-testare vor diferi. Încă o dată, ideea de a avea scripturi C ++ ca limbaj de script separat pentru proiectele TestComplete este de a permite dezvoltatorilor, obișnuiți cu C ++, să scrie cod de script care necesită modificări minime atunci când sunt importate în aplicații C ++. Când scrieți un astfel de cod în C ++ Script, vă rugăm să rețineți următoarele reguli, care disting Cript + Script de JScript: Atunci când apelați metode, utilizați numai următoarea notare: numele metodei sunt citate și plasate între paranteze, iar parametrii lor sunt plasați între paranteze: C ++ Script Jurnal ["Mesaj"] ("Mesajul meu", "Descrierea mesajului meu", 0, 1); TestComplete folosește această notație atunci când înregistrează rutine C ++ Script. JScript utilizează o altă notație pentru apelurile de metodă: JScript Log.Message („Mesajul meu”, „Descrierea mesajului meu”, 0, 1); Ar trebui să evitați această notare, deoarece nu este acceptată în C ++. În caz contrar, va trebui să rescrieți codul atunci când îl importați în C ++. Pentru a aborda proprietățile din C ++ Script, ar trebui să utilizați și paranteze pătrate. De exemplu: C ++ Script p = w [„Părinte”]; // Salvarea valorii proprietății la o variabilă Sys ["MouseX"] = 100; // Alocarea valorii proprietății Pentru a avea acces la o proprietate indexată, folosiți următoarea sintaxă: . De exemplu:object["property_name"](index) C ++ Script var p = TestedApps ["Elemente"] (0); // Obținerea valorii proprietății TestedApps ["Elemente"] (0) = "notepad.exe"; // Setarea valorii proprietății Nu utilizați declarații JScript withși for...inși operatorii JScript ===, !==, >>>sau >>>=. Nu sunt acceptate în C ++. Dacă le utilizați, va trebui să vă actualizați codul atunci când îl importați într-o aplicație C ++. De asemenea, aceste obiecte JScript nu sunt acceptate în prezent în aplicații C ++: Array, Boolean, Date, Function, Global, Math, Number, Object, RegExp, Errorși String. Utilizați punct și virgulă la sfârșitul fiecărei afirmații. Când ați introdus rutinele Script C ++ în cod C ++, încercați să compilați codul. Aceasta vă va spune dacă conține erori și unde le puteți găsi. Mai jos sunt cele mai frecvente modificări pe care poate fi necesar să le faceți: C ++ Script utilizează numai VARIANTtipul de date, astfel încât nu este necesară specificarea tipului de excepții în try... catchblocuri. În C ++ trebuie să specificați întotdeauna tipurile de excepție. Ar trebui să inițializați bibliotecile COM înainte de a rula scripturile importate și de a le inițializa atunci când scripturile nu mai funcționează. Cel mai simplu mod de a face acest lucru în aplicația dvs. este să utilizați IMPLEMENT_TESTCOMPLETE_GLOBAL_OBJECTS_MTAsau IMPLEMENT_TESTCOMPLETE_GLOBAL_OBJECTSmacros declarate în fișierul <TestComplete> \ Aplicații conectate \ C ++ \ scripts.h. Pentru mai multe informații despre aceste macro-uri, consultați Crearea aplicațiilor de auto-testare în C ++ sau Crearea de aplicații conectate în C ++ . Chiar dacă COM a fost deja inițializat cumva, aceste macro-uri nu vor dăuna nimic, așa că vă recomandăm să le utilizați întotdeauna. Modificați instrucțiunile care atribuie valori proprietăților indexate. Pentru a seta o proprietate indexată, utilizați următoarea sintaxă: sau . De exemplu:object[Put("property_name")](index)object[(Put)"property_name"](index) C ++ Script TestedApps [Put ("Elemente")] (0) = "notepad.exe"; sau TestedApps [(Put) "Elemente"] (0) = "notepad.exe"; Dacă funcția dvs. C ++ Script returnează o valoare, ar trebui să modificați sintaxa ei după ce a fost importată în aplicația dvs. C ++: C ++ Script // Funcția returnează o funcție de valoare Func1 () { return m; } C ++ // Funcția returnează o valoare int Func1 () { return m; } Dacă funcția dvs. script nu returnează valorile, nu puteți modifica sintaxa acesteia, deoarece fișierul script.h, inclus în aplicația C ++, deține următoarea declarație: functia voievodului tipedef Deci, cuvântul cheie funcțional este identic cu void. De exemplu: C ++ Script // Funcția nu returnează o funcție valorică Func1 () { } C ++ // Funcția nu returnează o valoare void Func1 () { } // sau funcția Func1 () { } Rețineți că, pe lângă TestComplete, Script.h vă permite să lucrați cu alte servere COM, de exemplu cu Microsoft Word, în același mod. Script.h simplifică sintaxa folosită în aplicațiile C ++ pentru a lucra cu serverele COM prin legare tardivă. După ce ați obținut IDispatchinterfața serverului dorit, puteți adresa metodele și proprietățile acesteia folosind sintaxa C ++ Script în loc să apelați la GetIDsOfName, Invokeși alte metode: C ++ Script #include "c: \ TestComplete \ Aplicații conectate \ C ++ \ script.h" ... folosind spațiul de nume TestComplete; void Test () { / * Am folosit variabila COleInit și nu funcțiile API CoInitializeEx și CoUninitialize. * / COleInit g; var wrd; / * Metoda GetObject returnează o referință la serverul COM dorit. Realizează acțiunile, similare cu cele de mai jos: IDispatch * wrdVar; GUID WrdClass; CLSIDFromProgID (L "Word.Application", & WrdClass); CoCreateInstance (WrdClass, NULL, CLSCTX_LOCAL_SERVER, IID_IDispatch, (void **) & wrdVar); wrd = wrdVar; * / wrd.GetObject (L "Word.Application"); / * Codul următor efectuează unele operații cu serverul COM * / wrd ["Vizibil"] = true; wrd [ "Documente"] [ "Add"] (); wrd ["Selection"] ["InsertAfter"] ("Hello, world!");
  2. Programare Shell cu bash: de exemplu, prin contra-exemplu Ca o coajă interactivă, bash este un limbaj obișnuit pentru inițierea și direcționarea calculelor. Ca limbaj de script, bash este un limbaj specific domeniului pentru manipularea și compunerea proceselor și fișierelor. Bash-ul este baroc. Bash este casant. Bash este indispensabil. Bash nu a fost proiectat. Nu este corect să spunem că bash a evoluat nici ea: păstrează și folosește toate apendicele sale vestigiale. Citiți mai departe pentru scurtul meu ghid bazat pe exemple de bash, inclusiv acoperirea de: variabile și tablouri; operațiuni pe variabile; aspecte subtile ca *versus @; aritmetic; siruri de caractere; domeniul de aplicare; fișiere și redirecționare; conducte; procese; modele; structuri de control; capcane. Am încercat să fac din aceasta o introducere unică, care să cuprindă toate elementele comune și un bun fragment din avansate. Dacă sunteți nou la programarea Unix și / sau shell, vă recomand să începeți cu: Un ghid de supraviețuire pentru Unix ; și / sau Stabilirea în Unix . Ce este bash? Bash este un shell interactiv: Tastați comenzi. Bash le execută. Utilizatorii Unix petrec mult timp manipulând fișierele de pe shell. Ca shell, este disponibil direct prin terminal, atât în Mac OS X (Aplicații> Utilități), cât și în Linux / Unix. În același timp, bash este și un limbaj de script: Scripturile Bash pot automatiza rutina sau sarcinile dificile implicate în administrarea sistemelor. De ce să folosești bash? Iată exemple de sarcini pentru care puteți utiliza bash: Orchestrând activitățile de pornire / oprire a sistemului. Redenumirea automată a unei colecții de fișiere. Găsirea tuturor fișierelor mp3 duplicate pe un hard disk. Orchestrând o suită de instrumente pentru crearea unei baze de date cu parole. Găsirea cuvintelor nevăzute în scrisul tău. Implementarea unei baze de date relaționale din fișierele text. Simplificarea configurației și reconfigurării software-ului. Bash ca limbaj de script Pentru a crea un script bash, plasați #!/bin/bash în partea de sus a fișierului. Apoi, schimbați permisiunile din fișier pentru a-l face executabil: $ chmod u + x nume de script Pentru a executa scriptul din directorul curent, puteți rula și trece orice parametru doriți. ./scriptname Când shell-ul execută un script, acesta găsește . #!/path/to/interpreter Apoi rulează interpretul (în acest caz /bin/bash) pe fișierul în sine. #!Convenția este motivul pentru care atât de multe limbaje de scripting folosesc #pentru comentarii. Iată un exemplu de script bash care tipărește primul argument: #! / Bin / bash # Utilizați $ 1 pentru a obține primul argument: ecou $ 1 Comentarii Comentariile în bash încep cu #și rulează până la sfârșitul liniei: ecou Bună ziua, lume. # tipărește „Hello, World”. Variabile / Arrays Variabilele în bash au o dublă natură atât ca tablouri cât și ca variabile. Pentru a seta o variabilă, utilizați =: foo = 3 # setează foo la 3 Dar, asigurați-vă că evitați să folosiți spații: foo = 3 # eroare: invocă comanda `foo 'cu argumente` =' și `3 ' Dacă doriți să utilizați un spațiu, puteți să vă scufundați în sub-limbajul de expresie care există în interior (( și )): ((foo = 3)) # Setează foo la 3. Pentru a face referire la valoarea unei variabile, utilizați un semn dolar $: ecou $ foo; # tipărește valoarea foo pentru stdout Puteți șterge o variabilă cu unset: foo = 42 ecou $ foo # imprimeuri 42 nesimțit foo echo $ foo # tipărește nimic Desigur, puteți atribui o variabilă alteia: foo = $ bar # atribuie valoarea lui $ bar lui foo. Dacă doriți să atribuiți o valoare care conține spații, asigurați-o că o citați: # gresit: foo = xyz # setează foo pe x; va încerca să execute y pe z # dreapta: foo = "xy z" # setează foo pe "xy z" Uneori este necesar să înfășurați o referință la o variabilă este bretele: ecou $ {foo} # imprimeuri $ foo Această notare este necesară pentru operații și tablouri variabile. Nu este necesară declararea unei variabile ca tablou: fiecare variabilă este un tablou. Puteți începe să utilizați orice variabilă ca matrice: foo [0] = "primul" # stabilește primul element la "primul" foo [1] = "secund" # stabilește cel de-al doilea element pe "al doilea" Pentru a face referire la un index, folosiți notarea bretele: foo [0] = "unu" foo [1] = "doi" ecou $ {foo [1]} # tipărește „două” Când faceți referință la o variabilă, aceasta este o referință implicită la primul index: foo [0] = "unu" foo [1] = "doi" ecou $ foo # tipărește „unul” Puteți utiliza, de asemenea, paranteze pentru a crea un tablou: foo = ("aa a" "bb b" "cc c") echo $ {foo [2]} # imprimeuri „cc c” ecou $ foo # imprimeuri „aa a” Pentru a accesa toate valorile dintr-un tablou, utilizați abonamentul special @sau *: array = (abc) ecou $ array # imprimeuri a echo $ {array [@]} # imprimeuri abc echo $ {array [*]} # imprimeuri abc Pentru a copia un tablou, utilizați abonament @, înconjurați-l cu ghilimele și înconjurați-l cu paranteze: foo = (abc) bar = ( "$ {foo [@]}") echo $ {bar [1]} # imprimeuri b Nu încercați să copiați doar variabila: foo = (abc) bar = $ foo echo $ {bar [1]} # nu tipărește nimic Și nu uitați ghilimelele sau altfel se vor înșela tablouri cu elemente care conțin spațiu: foo = ("a 1" "b 2" "c 3") bar = ($ {foo [@]}) Baz = ( "$ {foo [@]}") ecou $ {bar [1]} # oops, imprimați „1” ecou $ {baz [1]} # imprimeuri "b 2" Variabile speciale Există variabile de bază speciale pentru preluarea argumentelor la scripturi și funcții: echo $ 0 # tipărește numele scriptului echo $ 1 # tipărește primul argument echo $ 2 # tipărește al doilea argument echo $ 9 # tipărește cel de-al nouălea argument echo $ 10 # tipărește primul argument, urmat de 0 echo $ {10} # tipărește al zecelea argument echo $ # # tipărește numărul de argumente Variabila $?păstrează „starea de ieșire” a procesului executat anterior. O stare de ieșire de 0 indică procesul „reușit” fără eroare. O stare de ieșire, alta decât 0, indică o eroare. În programarea shell, trueeste un program care „reușește” întotdeauna și falseeste un program care „eșuează” întotdeauna: Adevărat ecou $? # imprimeuri 0 fals ecou $? # nu va tipări niciodată 0; de obicei tipărește 1 ID-ul procesului actualului shell este disponibil ca $$ ID-ul procesului din cel mai recent proces cu fundal este disponibil ca $!: # sortează două fișiere în paralel: sortare cuvinte> cuvinte sortate & proces de fundal lansare # p1 = $! sortare numere-n> numere sortate și # proces de fundal de lansare p2 = $! așteptați $ p1 așteptați $ p2 ecou Ambele fișiere au fost sortate. Operațiuni asupra variabilelor Într-o caracteristică unică în multe limbi, bash poate funcționa pe valoarea unei variabile în timp ce abandonează acea variabilă. Înlocuirea șirurilor Bash poate înlocui un șir cu un alt șir: foo = "Sunt o pisica". ecou $ {foo / pisică / câine} # amprentele „Sunt câine”. Pentru a înlocui toate instanțele unui șir, utilizați clape duble: foo = "Sunt o pisică, iar ea este pisica". ecou $ {foo / pisică / câine} # amprentele „Sunt un câine și ea este o pisică”. ecou $ {foo // pisică / câine} # imprimeuri „Sunt un câine și ea este un câine”. În general, aceste operații nu modifică variabila: foo = "hello" ecou $ {foo / salut / goodbye} # imprimeuri „la revedere” ecou $ foo # încă imprimă „salut” Fără înlocuire, se șterge: foo = "Imi plac chiftelutele." ecou $ {foo / balls} # imprimeuri îmi place carnea. Operațiune elimină cel mai scurt prefix de potrivire , în timp ce elimină cea mai lungă: ${name#pattern}${name}pattern## minipath = "/ usr / bin: / bin: / sbin" ecou $ {minipath # / usr} # printuri / bin: / bin: / sbin ecou $ {minipath # * / bin} # printuri: / bin: / sbin ecou $ {minipath ## * / bin} # printuri: / sbin Operatorul %este același, cu excepția sufixelor în locul prefixelor: minipath = "/ usr / bin: / bin: / sbin" echo $ {minipath% / usr *} # nu tipărește nimic echo $ {minipath% / bin *} # printuri / usr / bin: ecou $ {minipath %% / bin *} # printuri / usr Manipularea șirurilor / tablelor Bash are operatori care operează atât pe tablouri cât și pe șiruri. De exemplu, operatorul prefixului #numără numărul de caractere dintr-un șir sau numărul de elemente dintr-un tablou. Este o greșeală obișnuită să operezi accidental pe primul element al unui tablou ca șir, când intenția era să funcționeze pe tablou. Chiar și Ghidul Bash pentru începători conține un exemplu înșelător: ARRAY = (unu două trei) echo $ {# ARRAY} # imprimeuri 3 - lungimea tabloului? Cu toate acestea, dacă modificăm puțin exemplul, se pare că se rupe: ARRAY = (abc) ecou $ {# ARRAY} # imprimeuri 1 Acest lucru se datorează faptului că ${#ARRAY}este același ${#ARRAY[0]}, care contează numărul de caractere din primul element a,. Este posibil să numărați numărul elementelor din tablă, dar tabloul trebuie specificat explicit cu @: ARRAY = (abc) ecou $ {# ARRAY [@]} # imprimeuri 3 De asemenea, este posibil să tăiați șiruri și tablouri: string = "Sunt un fan al câinilor". echo $ {string: 6: 3} # fan tipărește array = (abcdefghij) echo $ {array [@]: 3: 2} # imprimeuri de Testarea existenței Unele operații testează dacă variabila este setată: nume de utilizator nesetat echo $ {username-default} # imprime implicit Nume de utilizator admin = echo $ {username-default} # imprime admin Pentru operațiunile care testează dacă o variabilă este setată, pot fi obligate să verifice dacă variabila este setată și nu este golă prin adăugarea unui punct (" :"): nesimțit foo bara nesetată ecou $ {foo-abc} # imprimeuri abc echo $ {bar: -xyz} # print xyz foo = "" bar = "" echo $ {foo-123} # tipărește nimic echo $ {bar: -456} # imprimeuri 456 Operatorul =(sau :=) este ca și operatorul -, cu excepția faptului că stabilește și variabila dacă nu are nicio valoare: cache-ul nesetat echo $ {cache: = 1024} # imprimeuri 1024 echo $ cache # imprimeuri 1024 echo $ {cache: = 2048} # imprimeuri 1024 echo $ cache # imprimeuri 1024 +Operatorul dă valoarea dacă variabila este setată, și nimic altceva: nesimțit foo bara nesetată foo = 30 ecou $ {foo + 42} # imprimeuri 42 echo $ {bar + 1701} # tipărește nimic Operatorul ?blochează programul cu mesajul specificat dacă variabila nu este setată: : $ {1? Eșec: niciun argument}} blocă programul dacă nu există primul argument ( :Comanda ignoră toate argumentele sale și este echivalentă cu true.) Privire indirectă Bash permite căutare indirectă a variabilei / a tabloului cu !operatorul prefixului. Adică se comportă ca și dacă numai asta a funcționat: ${!expr}${${expr}} foo = bar bar = 42 ecou $ {! foo} # tipărește $ bar, care este 42 alpha = (abcdefghijklmnopqrstu vwxyz) char = alpha [12] ecou $ {! char} # tipărește $ {alpha [12]}, care este m Array quirks: * versus @ Există două variabile speciale suplimentare: $*și [email protected] [Toate comportamentele descrise în această secțiune se aplică tablourilor atunci când sunt accesate prin intermediul sau de asemenea.] ${array[*]}${array[@]} Ambele par să conțină argumentele transmise scriptului / procedurii curente, dar au un comportament subtil diferit atunci când sunt citate: Pentru a ilustra diferența, trebuie să creăm câteva scripturi de ajutor. În primul rând, creați print12: #! / Bin / bash # tipărește primul parametru, apoi al doilea: ecou "primul: $ 1" ecou "secundă: $ 2" Apoi, creați showargs: #! / Bin / bash ecou $ * ecou $ @ ecou „$ *” ecou „$ @” bash print12 "$ *" bash print12 "$ @" Acum, executați showargs: $ bash showargs 0 "1 2 3" la imprimare: 0 1 2 3 0 1 2 3 0 1 2 3 0 1 2 3 întâi: 0 1 2 3 al doilea: primul: 0 al doilea: 1 2 3 Acest lucru se întâmplă deoarece "$*"combină toate argumentele într-un singur șir, în timp ce "[email protected]"necesită argumente individuale. Există o altă diferență subtilă între cele două: dacă variabila IFS(separator de câmp intern) este setată, atunci conținutul acestei variabile este împărțit între elementele din "$*". Creați un script numit atvstar: #! / Bin / bash IFS = "" ecou $ * ecou $ @ ecou „$ *” ecou „$ @” Și executați-l: $ bash atvstar 1 2 3 la imprimare: 1 2 3 1 2 3 1,2,3 1 2 3 IFS trebuie să conțină un singur caracter. Din nou, aceste aceleași comportamente de citare se transferă în tablouri atunci când sunt subscrise cu *sau @: arr = ("a b" "cd e") echo $ {arr [*]} # imprimeuri abcde ecou $ {arr [@]} # imprimeuri abcde ecou „$ {arr [*]}” # imprimeuri abcde ecou „$ {arr [@]}” # imprimeuri abcde bash print12 "$ {arr [*]}" # amprente: # primul: abcde # al doilea: bash print12 "$ {arr [@]}" # amprente: # primul: ab # al doilea: cde Corzi și cotare Șirurile în bash sunt secvențe de caractere. Pentru a crea un șir literal, utilizați ghilimele unice; pentru a crea un șir interpolat, utilizați ghilimele duble: Lume = Pământ foo = 'Bună ziua, lume $!' bar = "Bună ziua, lume $!" ecou $ foo # imprimeuri Bună ziua, lume $! ecou $ bar # imprimeuri Bună, Pământ! În șirurile intepolate, variabilele sunt convertite la valorile lor. domeniu În bash, domeniul de aplicare variabil este la nivelul proceselor: fiecare proces are propria copie a tuturor variabilelor. În plus, variabilele trebuie marcate pentru exportul în procesele copil: foo = 42 bash somescript # somescript nu poate vedea foo export foo bash somescript # somescript poate vedea foo ecou "foo =" $ foo # tipărește întotdeauna foo = 42 Să presupunem că acesta este somescript: #! / Bin / bash ecou "vechi foo = $ foo" foo = 300 ecou "new foo = $ foo" Ieșirea din cod ar fi: foo veche = foo nou = 300 foo veche = 42 foo nou = 300 foo = 42 Expresii și aritmetică Este posibil să scrieți expresii aritmetice în bash, dar cu o anumită prudență. Comanda exprtipărește rezultatul expresiilor aritmetice, dar trebuie să aveți grijă: expr 3 + 12 # imprimeuri 15 expr 3 * 12 # (probabil) se prăbușește: * se extinde la toate fișierele expr 3 \ * 12 # imprimeuri 36 Notația de atribuire este mai iertator: (( assignable = expression )) ((x = 3 + 12)); ecou $ x # imprimeuri 15 ((x = 3 * 12)); ecou $ x # imprimeuri 36 Dacă doriți rezultatul unei expresii aritmetice fără atribuirea acesteia, puteți utiliza : $((expression)) ecou $ ((3 + 12)) # imprimeuri 15 ecou $ ((3 * 12)) # imprimeuri 36 În timp ce declararea variabilelor implicit este norma în bash, este posibil să se declare explicit variabile și să se atașeze un tip la ele. Formularul creează o variabilă întreagă explicită: declare -i variable declara numarul -i număr = 2 + 4 * 10 ecou numărul $ # imprimeuri 42 alt = 2 + 4 * 10 ecou $ alt # imprimeuri 2 + 4 * 10 număr = "foobar" ecou numărul $ # imprimeuri 0 Atribuirile pentru variabile întregi vor forța evaluarea expresiilor. Fișiere și redirecționare Fiecare proces din Unix are acces la trei canale de intrare / ieșire în mod implicit: STDIN (intrare standard), STDOUT (ieșire standard) și STDERR (eroare standard). Când scrieți în STDOUT, ieșirea apare (implicit) la consolă. Când citiți de la STDIN, acesta citește (implicit) direct din ceea ce utilizatorul introduce în consolă. Când scrieți în STDERR, ieșirea apare (implicit) la consolă. Toate aceste canale pot fi redirecționate. De exemplu, pentru a descărca conținutul unui fișier în STDIN (în loc să accepte introducerea utilizatorului), utilizați <operatorul: # tipărește linii în fișier care conțin cuvântul foo: grep foo <myfile Pentru a descărca ieșirea unei comenzi într-un fișier, utilizați >operatorul: # concatenează fișier1 cu fișier2 în fișier nou combinat: cat file1 file2> combinat Pentru a adăuga la sfârșitul unui fișier, utilizați >>operatorul: # scrie data și ora curente până la sfârșitul unui fișier numit jurnal: data >> jurnal Pentru a specifica conținutul STDIN literal, într-un script, utilizați notația: <<endmarker pisica << ÎNAINTE Toate acestea vor fi tipărite. Deoarece toate acestea intră în pisică pe STDIN. UNTILHERE Totul până la următoarea instanță de endmarkerla sine pe o linie este redirecționat către STDIN. Pentru a redirecționa ieșirea de eroare (STDERR), utilizați operatorul 2>: # scrie erori de la pornirea demonului web la un jurnal de erori: httpd 2> eroare.log De fapt, toate canalele I / O sunt numerotate, și >este aceeași ca și 1>. STDIN este canalul 0, STDOUT este canalul 1, în timp ce STDERR este canalul 2. Notația redirecționează ieșirea canalului M la canalul N . M>&N Deci, este simplu să afișăm erori pe STDOUT: grep foo nofile 2> & 1 # erori vor apărea pe STDOUT Captarea STDOUT cu backquotes Există o altă formă citând în bash care arata ca un șir de caractere - backtick: ``. Aceste ghilimele execută comenzile din interiorul lor și renunță la ieșirea procesului în loc: # scrie data și utilizatorul în jurnal: ecou `data`` whoami` >> jurnal Având în vedere că uneori este utilă pentru a cuibări aceste extinderi, cochilii mai noi au adăugat o notație nestabilă : $(command) # scrie data și utilizatorul în jurnal: ecou $ (data) $ (whoami) >> jurnal Este tentant să importăm conținutul unui fișier , dar există o scurtătură simplă încorporată :`cat path-to-file``<path-to-file` echo user: `<config / USER` # tipărește conținutul config / USER Redirecționare cu exec Comanda specială bash execpoate manipula canalele peste game de comenzi: exec <file # STDIN a devenit fișier exec> fișierul # STDOUT a devenit fișier Poate doriți să salvați STDIN și STDOUT pentru a le restabili ulterior: exec 7 <& 0 # STDIN salvat ca canal 7 exec 6> & 1 # STDOUT salvat ca canal 6 Dacă doriți să înregistrați toate ieșirile dintr-un segment de script, puteți combina acestea împreună: exec 6> & 1 # STDOUT salvat ca canal 6 exec> LOGFILE # toate rezultatele ulterioare se duc la LOGFILE # pune comenzile aici exec 1> & 6 # restaurează STDOUT; ieșire la consolă din nou Țevi De asemenea, este posibil să rutați STDOUT-ul unui proces către STDIN-ul altuia folosind |operatorul (conductă): # tipărește intrarea root în baza de date cu parola utilizatorului: pisică / etc / passwd | rădăcină grep Forma generală a operatorului de conducte este: ieșire-comandă | inputing-comandă Și, este posibilă încadrarea comenzilor în „conducte”: # Un singur liner pentru a găsi porți spațiale în directorul curent: # du-rachete * # tipărește utilizarea spațiului numărul de fișiere din directorul curent # sort -rn # sorts STDIN, numeric, # de prima coloană în ordine inversă # head # tipărește primele 10 intrări de la STDIN du-rachete * | sort -rn | cap Unele programe acceptă un nume de fișier din care să citească în loc să citească de la STDIN. Pentru aceste programe sau programe care acceptă mai multe nume de fișiere, există o modalitate de a crea un fișier temporar care conține ieșirea unei comenzi, formularul. <(command) Expresia se extinde în numele unui fișier temporar care conține ieșirea de rulare . <(command)command Aceasta se numește substituirea procesului. # adaugă uptime, data și ultima linie de eveniment.log pe main.log: pisica <(uptime) <(data) <(coada -1 eveniment.log) >> main.log procese Bash excelează la procesele de coordonare. Conductele acționează pentru a coordona mai multe procese împreună. De asemenea, este posibil să rulați procesele în paralel. Pentru a executa o comandă în fundal, utilizați & operatorul postfix: timp consumator de timp & Și, pentru a obține id-ul procesului, utilizați $!variabila specială imediat după nașterea procesului: timp consumator de timp & pid = $! Cele mai waitasteapta comanda pentru proces asociat unui proces de id pentru a termina: timp consumator de timp & pid = $! asteapta $ pid proces ecou $ pid terminat. Fără un cod de proces, waitașteaptă ca toate procesele copilului să se termine. Pentru a converti un folder de imagini din JPG în PNG în paralel: pentru f în * .jpg do convertiți $ f $ {f% .jpg} .png & Terminat aștepta ecou Toate imaginile au fost convertite. Globuri și modele Bash furnizează utilizarea notării glob pentru a se potrivi pe șiruri și nume de fișiere. În majoritatea contextelor din bash, un model glob se extinde automat la o serie de nume de fișiere potrivite: echo * .txt # tipărește numele tuturor fișierelor text echo *. {jpg, jpeg} # tipărește numele tuturor fișierelor JPEG Modelele glob au mai multe forme speciale: * se potrivește cu orice șir. ? se potrivește cu un singur personaj. [chars]se potrivește cu orice personaj din chars. [a-b]se potrivește cu orice personaj între ași b. Folosind aceste tipare, este ușor să eliminați toate fișierele formularului , unde este un număr de 3 cifre: fileNNNNNN fișier rm [0-9] [0-9] [0-9] Forma creată „set” cret pare să acționeze ca un model, dar se va extinde chiar dacă fișierele nu există: se extinde la sau sau ... {string1,string2,...,stringN}string1string2 Este posibil să se creeze o "bombă bash": un model care crește exponențial ca dimensiune sub expansiune: ecou {0,1} # imprimeuri 0 1 ecou {0,1} {0,1} # imprimeuri 00 01 10 11 ecou {0,1} {0,1} {0,1} # imprimeuri 000 001 010 011 100 101 110 111 Structuri de control La fel ca majoritatea limbilor, bash acceptă structuri de control pentru condiționări, iterație și subrutine. Condiționalele Dacă există alte condiții, în bash, ca în alte limbi. Cu toate acestea, în bash condiția este o comandă, iar o stare de ieșire a succesului (0) este „true”, în timp ce o stare de ieșire a eșecului (non-zero) este „falsă”: # aceasta va tipări: daca e adevarat atunci ecou tipărit Fi # aceasta nu va tipări: dacă este fals atunci ecou neimprimat Fi Bash poate întreprinde diferite acțiuni cu privire la succesul sau eșecul unui program: dacă httpd -k începe atunci ecou "httpd a început OK" altfel ecou "httpd nu a reușit să înceapă" Fi În bash, multe condiții sunt construite din comanda specială test. Testul de comandă necesită multe stegulețe pentru a efectua teste condiționate. Fugiți help testsă le enumerați pe toate. Unele steaguri populare includ: -e file este adevărat dacă există un fișier / director specific. -z string este adevărat dacă șirul dat este gol. string1 = string2 este adevărat dacă cele două șiruri sunt egale. Există o notație alternativă pentru utilizarea paranteze pătrate: . test args[ args ] Condiționalele pot verifica dacă argumentele au semnificație: dacă ["$ 1" = "-v"] atunci ecou „trecerea la ieșirea verboasă” VERBOSE = 1 Fi Repetare Forma execută până când testul comanda se completează cu starea de iesire nenulă: while command; do commands; donecommands # reporni automat httpd-ul în cazul în care se blochează: în timp ce adevărat do httpd Terminat Este posibil să iterați elementele dintr-un tablou cu o buclă: for var in array; do commands; done # compila toate fișierele c dintr-un director în binare: pentru f în * .c do gcc -o $ {f% .c} $ f Terminat subrutine Subrutinele Bash sunt ca niște scripturi separate. Există două sintaxe pentru definirea unei subrutine: nume funcție { comenzi } și: nume () { comenzi } După ce a declarat, o funcție acționează aproape ca un script separat: argumente pentru funcția de vin ca pentru n - lea argument. $n O diferență majoră este că funcțiile pot vedea și modifica variabile definite în scriptul exterior: count = 20 funcție showcount { ecou $ count count = 30 } showcount # imprimeuri 20 echo $ count # printuri 30 Exemple Îmbunătățirea acestui lucru ne permite să scriem programe în bash. Iată o subrutină pentru calcularea factorială: fapt funcție { rezultat = 1 n = $ 1 în timp ce ["$ n" -gege 1] do rezultat = $ (expr $ n \ * $ rezultat) n = $ (expr $ n - 1) Terminat ecou rezultat $ } Sau, cu notarea expresiei: function facter { rezultat = 1 n = $ 1 while ((n> = 1)) do ((rezultat = n * rezultat)) ((n = n - 1)) Terminat ecou rezultat $ } Sau, cu variabile întregi declarate: factered () { declara-i rezultat declară -in n = $ 1 rezultat = 1 while ((n> = 1)) do Rezultatul = n * rezultat n = n-1 Terminat ecou rezultat $ }
  3. Ultimul exemplu susține opțiunile care pot fi transmise de la linia de comandă, de exemplu prin ./loc7.sh -d 1 loc7.sh . Funcția getopts shell este folosită pentru a itera peste toate opțiunile (date în șirul următor) și pentru a atribui opțiunea curentă variabilei name. De obicei este utilizat într-o buclă de timp, pentru a seta variabile de shell care vor fi utilizate ulterior. Folosim o țeavă de pisică și awk pentru a imprima antetul acestui fișier, până la prima linie goală, dacă opțiunea de ajutor este aleasă. Partea principală a scriptului este o buclă pentru toate argumentele din linia de comandă care nu sunt opționale. În fiecare iterație, $fconține numele fișierului de procesat. Dacă opțiunile datei sunt utilizate pentru a restrânge sfera fișierelor de procesat, folosim datași o declarație if, pentru a compara dacă timpul de modificare a fișierului este în intervalul specificat. Numai în acest caz numărăm liniile ca mai înainte. După buclă, vom tipări numărul total de linii și numărul de fișiere procesate. Exemplul : Număr linie pe mai multe fișiere #! / Bin / bash ################################################## ########################## # # Utilizare: loc7.sh [opțiuni] fișier ... # # Numărați numărul de linii dintr-o listă dată de fișiere. # Utilizează o buclă pentru toate argumentele. # # Opțiuni: # -h ... mesaj de ajutor # -dn ... ia în considerare doar fișierele modificate în ultimele n zile # -wn ... ia în considerare doar fișierele modificate în ultimele n săptămâni # # Limitări: #. ar trebui să se acorde o singură opțiune; un al doilea învinge # ################################################## ########################## ajutor = 0 verb = 0 săptămâni = 0 # valori implicite zile = 0 m = 1 str = "zile" getopts "hvd: w:" nume în timp ce ["$ nume"! = "?" ]; do cazul $ nume în h) ajutor = 1 ;; v) verb = 1 ;; d) zile = $ OPTARG m = $ OPTARG str = "zile" ;; w) săptămâni = $ OPTARG m = $ OPTARG str = "săptămâni" ;; ESAC getopts "hvd: w:" nume Terminat dacă [$ ajutor -eq 1] apoi no_of_lines = `cat $ 0 | awk 'ÎNCEPE {n = 0; } \ / ^ $ / {print n; \ Ieșire; } \ {n ++; } ' ` ecou "` cap - $ no_of_lines $ 0` " Ieșire Fi shift $ [$ OPTIND - 1] dacă [$ # -lt 1] atunci ecou „Utilizare: $ 0 fișier ...” iesirea 1 Fi dacă [$ verb -eq 1] apoi ecuați „$ 0 numără liniile de cod” Fi l = 0 n = 0 s = 0 pentru f în $ * do x = `stat -c"% y "$ f` # data modificării d = `data - data =" $ x "+% y% m% d` # data de $ m zile / săptămâni în urmă e = `data - data =" $ m $ str acum "+% y% m% d` # acum z = `data +% y% m% d` #echo "Stat: $ x; Acum: $ z; Fișier: $ d; $ m $ str acum: $ e" # verifică dacă fișierul este mai recent decât req dacă [$ d -ge $ e -a $ d -le $ z] # ToDo: fixați anotimpurile atunci # fi verbose dacă am găsit un fișier recent dacă [$ verb -eq 1] apoi ecuați „$ f: modificat (mmdd) $ d” Fi # face numarul de linii l = `wc -l $ f | sed 's / ^ \ ([0-9] * \). * $ / \ 1 /' ' ecou „$ f: $ l” # creșterea contoarelor n = $ [$ n + 1] s = $ [$ s + $ l] altfel # nu este strict necesar, deoarece este sfârșitul buclei continua Fi Terminat ecuați „$ n fișiere în total, cu $ s în linii în total”
  4. In această versiune definim o funcție count_lines care numără numărul de linii din fișierul furnizat ca argument. În cadrul funcției, valoarea argumentului este preluată prin accesarea variabilei $1. #! / Bin / bash # Numărarea numărului de linii dintr-o listă de fișiere # versiunea funcției count_lines () { local f = $ 1 # aceasta este valoarea de returnare, adică non-locală l = `wc -l $ f | sed 's / ^ \ ([0-9] * \). * $ / \ 1 /' ' } dacă [$ # -lt 1] atunci ecou „Utilizare: $ 0 fișier ...” iesirea 1 Fi ecou "$ 0 numără liniile de cod" l = 0 n = 0 s = 0 while ["$ *"! = ""] do numără_line $ 1 ecou „$ 1: $ l” n = $ [$ n + 1] s = $ [$ s + $ l] schimb Terminat ecuați „$ n fișiere în total, cu $ s în linii în total”
  5. Primul exemplu contează pur și simplu numărul de linii dintr-un fișier de intrare. O face prin interarea peste toate liniile unui fișier folosind o buclă while , executând o operație de citire în antetul buclei. În timp ce există o linie de procesat, corpul buclei va fi executat în acest caz, mărind pur și simplu un contor cu ((counter ++)) În plus, linia curentă este scrisă într-un fișier, al cărui nume este specificat de variabilă file, răsunând valoarea variabilei lineși redirecționând ieșirea standard a variabilei către $ file . linia curentă de fișier. Aceasta din urmă nu este necesară pentru numărul de linii, desigur, dar demonstrează cum să verificați pentru succesul unei operațiuni: variabila specială $?va conține codul de retur din comanda anterioară ( ecoul redirecționat ). Prin convenția Unix, succesul este indicat printr-un cod de retur de 0, toate celelalte valori sunt cod de eroare cu semnificație specifică aplicației. O altă problemă importantă de luat în considerare este aceea că variabila întreagă, peste care se efectuează iterația, trebuie să conteze întotdeauna pentru ca analiza să găsească o legătură. Aceasta ar putea necesita o restructurare a codului, ca în exemplul următor, unde este introdusă o contorizare explicită z în acest scop. După buclă, numărul de linii și conținutul ultimei linii sunt tipărite, folosind ecou . Desigur, există o comandă Linux care implementează deja funcționalitatea de numărare a liniilor: tipărirea wc (pentru cuvinte-conturi), când este apelată cu opțiunea -l , numărul de linii din fișier. Folosim acest lucru pentru a verifica dacă numărul nostru de linii este corect, demonstrând operațiuni numerice pe parcurs. Exemplu : #! / Bin / bash # Exemplu de număr de linii simple, folosind bash # # Tutorial Bash: http://linuxconfig.org/Bash_scripting_Tutorial#8-2-read-file-into-bash-array # Linkul meu de script: http://www.macs.hw.ac.uk/~hwloidl/docs/index.html#scripting # # Utilizare: fișier ./line_count.sh # ------------------------------------------------- ---------------------------- # Link fileescriptor 10 cu stdin exec 10 <& 0 # stdin înlocuit cu un fișier furnizat ca prim argument exec <$ 1 # amintiți-vă numele fișierului de intrare în = $ 1 # init fișier = "current_line.txt" lasa numararea = 0 # aceasta în timp ce bucla se iterează pe toate liniile fișierului în timp ce citiți LINIE do # creșterea contorului de linie ((COUNT ++)) # scrie linia curentă într-un fișier tmp cu nume $ file (nu este necesar pentru numărare) ecou $ LINE> $ fișier # aceasta verifică codul de retur al ecoului (nu este necesar pentru scriere; doar pentru demo) dacă [$? -ne 0] apoi ecuați "Eroare la scrierea în fișierul $ {file}; verificați permisiunile!" Fi Terminat ecou "Număr de linii: $ număr" ecou "Ultima linie a fișierului este:` cat $ {file} `" # Notă: Puteți obține același lucru folosind doar wc-ul cu acest instrument ecou "Numărul de linii preconizat:` wc -l $ in` " # restaurați stdin din fileescriptor 10 # și închideți fișierul descriptor 10 exec 0 <& 10 10 <& - Așa cum este documentat la începutul scriptului, acesta este numit astfel (trebuie să aveți un fișier text_file.txt în directorul curent): $ ./line_count.sh text_file.txt Notă Fișier text exemplu Puteți obține un fișier text de dimensiune important, tastând: $ cp /home/msc/public/LinuxIntro/WaD.txt text_file.txt
  6. Scripting limbaj Un script sau limbaj de script este un limbaj de programare pentru un speciale mediu run-time care automatizează executarea sarcinilor ; sarcinile ar putea fi executate alternativ, unul câte unul, de către un operator uman. Limbile de script sunt deseori interpretate (mai degrabă decât compilate ). Primitivele sunt de obicei sarcinile elementare sau apelurile API [ este nevoie de clarificări ] , iar limbajul le permite să fie combinate în mai multe programe. Mediile care pot fi automatizate prin scripturi includ aplicații software , pagini web dintr-un browser web , utilizarea de shell-uri a sistemelor de operare (OS), sisteme încorporate , precum și numeroase jocuri. Un limbaj de script poate fi privit ca un limbaj specific domeniului pentru un anumit mediu; în cazul scripturilor unei aplicații, este cunoscută și ca limbaj de extensie. Limbile de script sunt, de asemenea, uneori denumite limbaje de programare la nivel foarte înalt , deoarece operează la un nivel ridicat de abstractizare sau ca limbaje de control , în special pentru limbajele de control al locurilor de muncă de pe mainframes. Termenul "limbaj de script" este, de asemenea, utilizat neobișnuit pentru a face referire la limbaje dinamice de nivel general de înalt nivel , precum Perl , PowerShell , Python și Tcl cu termenul "script" folosit adesea pentru programe mici ( până la câteva mii de linii de cod) , în astfel de limbi, sau în limbile specifice unui domeniu , cum ar fi limbile de procesare a textului sed și AWK. Unele dintre aceste limbi au fost inițial dezvoltate pentru a fi utilizate într-un anumit mediu, ulterior dezvoltate în limbaje portabile specifice domeniului sau cu scop general. În schimb, multe limbi cu scop general au dialecte care sunt folosite ca limbaje de script. Acest articol discută despre limbajele de script în sensul restrâns al limbilor pentru un mediu specific. Spectrul limbajelor de scripturi variază de la limbaje foarte mici și foarte specifice domeniului, până la limbaje de programare cu scop general utilizate pentru scripturi. Exemple tipice de limbaje de scripting pentru medii specifice includ: Bash , pentru Unix sau Unix- ului sistemelor de operare ; ECMAScript ( JavaScript ), pentru browsere web; și Visual Basic pentru aplicații , pentru aplicațiile Microsoft Office . Lua este un limbaj conceput și utilizat pe scară largă ca limbă de extensie. Pitoneste un limbaj cu scop general, care este de asemenea utilizat în mod obișnuit ca limbaj de extensie, în timp ce ECMAScript este încă în primul rând un limbaj de script pentru browserele web, dar este folosit și ca limbaj general. Emacs Lisp dialect de Lisp (pentru Emacs editor) și Visual Basic pentru aplicații dialect al Visual Basic sunt exemple de dialecte limbaj de scripting de limbi de uz general. Unele sisteme de jocuri, în special lumea virtuală Second Life și franciza Trainz a simulatoarelor Railroad au fost extinse în funcționalitate prin extensii de script ( Linden Scripting Language și TrainzScript). În alte jocuri precum Wesnoth , varietatea jocurilor efective jucate de jucători sunt scripturi scrise de alți utilizatori. Cuprins 1 Caracteristici 2 Istorie 3 tipuri 3.1 Limbi de lipici 3.2 Limbi de control și coajă 3.3 Scripturi GUI 3.4 Limbi specifice aplicației 3.5 Limbi de extensie / încorporate Caracteristici Limbile de scripturi tipice sunt destinate să fie foarte rapide pentru a învăța și scrie, fie ca fișiere scurte de cod sursă, fie interactiv într-o buclă de citire-evaluare-imprimare (REPL, limbaj shell). Aceasta implică, în general, sintaxa și semantica relativ simplă ; de obicei, un „script” (cod scris în limbajul de script) este executat de la început până la sfârșit, ca „script”, fără punct de intrare explicit . De exemplu, este neobișnuit să caracterizăm Java ca un limbaj de script datorită sintaxei sale îndelungate și a regulilor cu privire la ce clase există în care fișiere și nu este posibil să se execute direct Java, deoarece fișierele sursă pot conține doar definiții care trebuie invocate. extern de către o aplicație gazdă sau un lansator de aplicații . Exemplu : public class HelloWorld { public void printHelloWorld () { Sistem . afară . println ( „Hello World” ); } } Această bucată de cod destinată tipăririi „Hello World” nu face nimic ca principal () nu este declarată în clasa HelloWorld . În schimb, Python permite definirea unor funcții într-un singur fișier, sau pentru a evita funcțiile cu totul și pentru a utiliza stilul de programare imperativ , sau chiar pentru a-l utiliza în mod interactiv. print ("Hello World") Această linie de cod Python tipărește „Hello World”; nicio declarație declarativă ca principal () nu este necesară aici. Un limbaj de script este de obicei interpretat din codul sursă sau bytecode . În schimb, mediul software pentru care sunt scrise scripturile este scris de obicei într-un limbaj compilat și distribuit sub formă de cod de mașină . Limbile de script pot fi proiectate pentru a fi utilizate de utilizatorii finali ai unui program - dezvoltarea utilizatorului final - sau poate fi utilizată doar de dezvoltatori, astfel încât să poată scrie porțiuni ale programului în limbajul de script. Limbajele de script folosesc, de obicei , abstractizarea , o formă de ascundere a informațiilor , pentru a rezerva utilizatorilor detaliile tipurilor variabile interne, stocarea datelor și gestionarea memoriei . Scripturile sunt adesea create sau modificate de persoana care le execută, , dar sunt, de asemenea, deseori distribuite, cum ar fi atunci când porțiuni mari de jocuri sunt scrise într-un limbaj de script. Istoric Calculatoarele mainframe timpurii (în anii '50) nu au fost interactive, utilizând în schimb procesarea lotului . IBM Job Control Language (JCL) este arhetipul limbajelor utilizate pentru a controla procesarea lotului. [7] Primele shell-uri interactive au fost dezvoltate în anii '60 pentru a permite funcționarea de la distanță a primelor sisteme de partajare a timpului , iar aceste scripturi utilizate , care controlau rularea programelor de calculator în cadrul unui program de calculator, shell-ul. Calvin Mooers în limbajul său TRAC este, în general, creditat că a inventat înlocuirea comenzilor , capacitatea de a încorpora comenzile în scripturi care atunci când sunt interpretate introduc o șir de caractere în script. [8] Multics numește aceste funcții active . Louis Pouzin a scris un procesor timpuriu pentru scripturile de comandă numite RUNCOM pentru CTSSîn jurul anului 1964. Stuart Madnick la MIT a scris un limbaj de script pentru CP / CMS IBM în 1966. El a numit inițial acest procesor COMMAND, mai târziu numit EXEC . Multics-urile includeau un offshoot al CTSS RUNCOM, numit și RUNCOM. EXEC a fost înlocuit în cele din urmă de EXEC 2 și REXX . Limbi precum Tcl și Lua au fost concepute special ca limbaje de script cu scop general, care ar putea fi încorporate în orice aplicație. Alte limbi, cum ar fi Visual Basic pentru aplicații (VBA), au furnizat o integrare puternică cu facilitățile de automatizare ale unui sistem de bază. Încorporarea unor astfel de limbaje de script cu scop general, în loc de a dezvolta un limbaj nou pentru fiecare aplicație, a avut și beneficii evidente, scutind dezvoltatorul aplicației de nevoia de a codifica un traducător de limbă de la zero și permite utilizatorului să aplice abilitățile învățate în altă parte. Unele software încorporează mai multe limbaje de scripturi diferite. Navigatoarele web moderne furnizează de obicei o limbă pentru scrierea extensiilor în browserul propriu-zis și mai multe limbi standard încorporate pentru controlul browserului, inclusiv JavaScript (un dialect ECMAScript ) sau XUL . Tipuri Limbi de lipici Această secțiune nu citează nicio sursă . Vă rugăm să ajute la îmbunătățirea acestui secțiune prin adăugarea de referințe bibliografice la surse de încredere . Materialele neaccesate pot fi contestate și eliminate . ( Martie 2007 ) ( Aflați cum și când să eliminați acest mesaj șablon ) Scripturile sunt deseori contrastate cu programarea sistemului , ca în dicotomia lui Ousterhout sau „ programare în mare și programare în mic ”. În această privință, scripturile sunt în special coduri de lipici , care conectează componente software și un limbaj specializat în acest scop este un limbaj de lipici . Conductele și scripturile de coajă sunt exemple arhetipale ale limbajelor de lipici, iar Perl a fost inițial dezvoltat pentru a ocupa același rol. Dezvoltarea web poate fi considerată o utilizare a limbajelor de lipici, interfațând între o bază de date și un server web. Dar, dacă se scrie o cantitate substanțială de logică în script, aceasta este mai bine caracterizată drept o altă componentă software, nu „lipici”. Limbile de lipici sunt deosebit de utile pentru scriere și întreținere: comenzi personalizate pentru un shell de comandă; programe mai mici decât cele care sunt mai bine implementate într-un limbaj compilat; [ nevoie de citare ] programe „înveliș” pentru executabile, cum ar fi un fișier batch care mișcă sau manipulează fișiere și face alte lucruri cu sistemul de operare înainte sau după rularea unei aplicații precum un procesor de text, foaie de calcul, bază de date, asamblator, compilator etc.; scripturi care se pot schimba; Dezvoltarea rapidă de aplicații a unei soluții implementată în cele din urmă într-un alt limbaj, de obicei compilat. Exemple de limbă cu clei: AppleScript ,Fuziune la rece ,DCL,Lisp comun incorporat ECL,Erlang,JCL,CoffeeScript,Julia JScript și JavaScript,Lua,m4,Pascal modern,Perl (5 și 6),PHP PowerShell,Pur,Piton,Rebol,roșu,rexx Rubin,Sistem,TCL Scripturi Unix Shell ( ksh , csh , bash , sh și altele) VBScript,Limbajul fluxului de lucru,XSLT Limbile macro expuse componentelor sistemului de operare sau ale aplicației pot servi drept limbaje de lipici. Acestea includ Visual Basic pentru aplicații , WordBasic , LotusScript , CorelScript , Hummingbird Basic, QuickScript, SaxBasic și WinWrap Basic . Alte instrumente precum AWK pot fi de asemenea considerate limbi de lipici, precum orice limbă implementată de un motor Windows Script Host (VBScript, JScript și VBA în mod implicit în motoarele Windows și terțe părți, inclusiv implementările Rexx, Perl, Tcl, Python, XSLT, Ruby, Pascal Modern, Delphi și C). Majoritatea aplicațiilor pot accesa și utiliza componente ale sistemului de operare prin intermediulmodele de obiecte sau funcții proprii. Alte dispozitive precum calculatoarele programabile pot avea, de asemenea, limbaje de lipici; sistemele de operare ale PDA-uri, cum ar fi Windows CE, pot avea instrumente macro disponibile native sau terțe părți care adună aplicații împreună, pe lângă implementări de limbaje comune de lipici - inclusiv Windows NT, MS-DOS și unele shell-uri Unix, Rexx, Modern Pascal, PHP și Perl. În funcție de versiunea de sistem de operare, WSH și motoarele de script implicite (VBScript și JScript) sunt disponibile. Calculatoarele programabile pot fi programate în limbi de lipici în trei moduri. De exemplu, Texas Instruments TI-92 , implicit din fabrică, poate fi programat cu un limbaj de script de comandă. Includerea scriptului și a limbajului de lipici Lua în TI-NSpireo serie de calculatoare ar putea fi văzută ca un succesor la acest aspect. Limbele de programare la nivel înalt la bordul majorității calculatoarelor grafice (cel mai adesea variante de bază, uneori derivate Lisp și mai puțin frecvente, derivate C), în multe cazuri, pot îmbina funcțiile calculatorului - cum ar fi grafice, liste, matrice etc. Sunt disponibile implementări terțe ale unei versiuni de bază mai cuprinzătoare, care pot fi mai aproape de variantele enumerate ca limbi de lipici în acest articol și sunt menționate și încercări de implementare a Perl, Rexx sau a diverselor shell-uri ale sistemului de operare pe calculatoarele grafice TI și HP. Compilatoare încrucișate C bazate pe PC pentru unele dintre mașinile TI și HP utilizate împreună cu instrumente care convertesc între C și Perl, Rexx, AWK, precum și scripturi shell la Perl, Modern Pascal, VBScript la și din Perl fac posibilă scrierea unui program într-un clei limbă pentru o eventuală implementare (ca program compilat) pe calculator. Limbaje de control al locurilor de muncă și coji de Articol principal: script Shell O clasă majoră de limbaje de scripturi a ieșit din automatizarea controlului postului , care se referă la pornirea și controlul comportamentului programelor de sistem. (În acest sens, s-ar putea considera că shell-urile sunt descendenți ai JCL-ului IBM, sau Job Control Language , care a fost folosit exact pentru acest scop.) Mulți dintre interpreții acestor limbi se dublează ca interpreți de linie de comandă, cum ar fi shell-ul Unix sau MS-DOS COMMAND.COM. Altele, precum AppleScript oferă utilizarea comenzilor asemănătoare cu limba engleză pentru a crea scripturi. Scripturi GUI Odată cu apariția interfețelor grafice de utilizator, a apărut un tip de limbaj de script specializat pentru controlul unui computer. Aceste limbi interacționează cu aceleași ferestre grafice, meniuri, butoane, etc., pe care le-ar face un utilizator uman. Acestea fac acest lucru simulând acțiunile unui utilizator. Aceste limbaje sunt utilizate de obicei pentru a automatiza acțiunile utilizatorilor. Astfel de limbi se mai numesc „ macros ” atunci când controlul se face prin apăsări de taste simulate sau clicuri de mouse, precum și prin atingerea sau apăsarea pe un ecran activat la atingere. Aceste limbaje ar putea fi, în principiu, utilizate pentru a controla orice aplicație GUI; dar, în practică, utilizarea lor este limitată, deoarece utilizarea lor are nevoie de sprijin din partea aplicației și din sistemul de operare . Există câteva excepții de la această limitare. Unele limbaje de script GUI se bazează pe recunoașterea obiectelor grafice din pixelii ecranului lor de afișare . Aceste limbaje de script GUI nu depind de suportul sistemului de operare sau al aplicației. Limbi specifice aplicației Limbile specifice aplicației pot fi împărțite în mai multe categorii diferite, adică limbaje de aplicație bazate pe standalone (executabile) sau limbi specifice aplicațiilor interne (postscript, xml, gscript, deoarece unele scripturi distribuite pe scară largă, respectiv implementate de Adobe, MS și Google), printre altele un limbaj de script idiomatic adaptat nevoilor utilizatorului aplicației. De asemenea, multe sisteme de jocuri de calculator folosesc un limbaj de script personalizat pentru a exprima acțiunile programate ale personajelor non-player și a mediului de joc. Limbile de acest fel sunt concepute pentru o singură aplicație; și, deși seamănă superficial cu un limbaj specific cu scop general (de exemplu , QuakeC , modelat după C), au caracteristici personalizate care le disting.Emacs Lisp , în timp ce un dialect complet format și capabil de Lisp , conține multe caracteristici speciale care îl fac cel mai util pentru extinderea funcțiilor de editare a Emacs. Un limbaj de script specific aplicației poate fi vizualizat ca un limbaj de programare specific domeniului specializat într-o singură aplicație. Limbi de extensie / încorporate O serie de limbi au fost concepute în scopul înlocuirii limbajelor de script specifice aplicației prin încorporarea în programele de aplicații. Programatorul de aplicații (care lucrează în C sau alt limbaj de sistem) include „cârlige” în care limbajul de script poate controla aplicația. Aceste limbi pot fi echivalente din punct de vedere tehnic cu un limbaj de extensie specific unei aplicații, dar atunci când o aplicație încorporează un limbaj „comun”, utilizatorul are avantajul de a putea transfera abilități de la aplicație la aplicație. O alternativă mai generică este pur și simplu furnizarea unei biblioteci (adesea o bibliotecă C) pe care un limbaj cu scop general îl poate utiliza pentru a controla aplicația, fără a modifica limba pentru domeniul specific. JavaScript a început deoarece și în primul rând este încă un limbaj pentru scripturi în browserele web ; cu toate acestea, standardizarea limbii ca ECMAScript a făcut-o populară ca limbaj încorporat cu scop general. În special, implementarea Mozilla SpiderMonkey este încorporată în mai multe medii precum Yahoo! Widget Engine . Alte aplicații de înglobare implementări ECMAScript includ Adobe produsele Adobe Flash ( ActionScript ) și Adobe Acrobat (pentru Scripting PDF fișiere). Tcl a fost creat ca limbaj de extensie, dar a ajuns să fie folosit mai frecvent ca limbaj de uz general în roluri similare cu Python , Perl și Ruby . Pe de altă parte, Rexx a fost inițial creat ca limbaj de control al postului, dar este utilizat pe scară largă ca limbaj de extensie, precum și ca limbaj de uz general. Perl este un limbaj de uz general, dar a avut dialectul Oraperl (1990), format dintr-un binar Perl 4 cu interfața de apel Oracle compilată. Totuși, de atunci, a fost înlocuit de o bibliotecă (modulul Perl), DBD :: Oracle . Alte aplicații complexe și orientate spre sarcini pot încorpora și expune un limbaj de programare încorporat pentru a permite utilizatorilor lor un control mai mare și a le oferi mai multă funcționalitate decât poate fi disponibilă printr-o interfață de utilizator, oricât de sofisticată. De exemplu, instrumentele de autorizare 3D Autodesk Maya 3D încorporează limbajul de script MEL sau Blender care folosește Python pentru a îndeplini acest rol. Unele alte tipuri de aplicații care necesită o adăugare mai rapidă de funcții sau cicluri de modificare și rulare (de ex. Motoare de joc ) folosesc, de asemenea, un limbaj încorporat. În timpul dezvoltării, acest lucru le permite să prototipizeze caracteristicile mai rapid și să regleze mai liber, fără a fi nevoie ca utilizatorul să aibă cunoștințe intime despre funcționarea interioară a aplicației sau să o reconstruiască după fiecare modificare (ceea ce poate dura o perioadă semnificativă de timp) . Limbile de script folosite în acest scop variază de la cele mai comune și mai cunoscute Lua și Python până la cele mai puțin cunoscute, cum ar fi AngelScript și veverița . Ch este o altă opțiune de script compatibilă C pentru industrie să se integreze în programele de aplicații C / C ++.
  7. În acest subiect este nevoie de posturi sau cerere cum ar fi dorit să fie mutate pentru echipa de îngrijire faceti parte. Înainte de această cerere este foarte obligatorie cititul și să fie respectat regulamentul !! Model: Nume: Rang: Motivul: Aprecizari: Dupa ce ati completat si postat cererea asteptati raspunsul liderului.

Bebe last won the day on January 14 2018

Bebe had the most liked content!

Community Reputation

26 Gold Nova

  1 Follower

  About

  • Rank
    Bos De Bos

×