buna, e posibil sa existe un auto clicker care se opreste atunci când pe ecran apare un anumit număr?
teoretic, asa cum exista sisteme de recunoastere a fetei (pentru camere), pot fi identificate si numere (de pe imaginea ecranului sau din semnalul trimis pe ecran).
evident, este nevoie de soft si echipament dedicat.
daca inchizi browserul sau dai shutdown acele evenimente vor fi emise. daca scoti din priza sau ramai fara curent nu vor mai fi emise. JavaScript nu are suport pentru multi-threading pentru că JavaScript interpret în browser-ul este un singur fir (AFAIK). Chiar și Google Chrome nu va lăsa o singură pagină web JavaScript rulează în același timp, deoarece acest lucru ar provoca distrugeri masive de probleme de concurenta în paginile web existente. Toate Chrome nu este de a separa mai multe componente (diferite tab-uri, plugin-uri, etc.) în procese separate, dar nu-mi pot imagina o singură pagină având mai mult de un JavaScript fir.


Cu toate acestea, puteți utiliza, așa cum a fost sugerat, `setTimeout` pentru a permite un fel de programare și "fals" de concurenta. Acest lucru provoacă browser-ul pentru a recâștiga controlul de redare fir, și începe cod JavaScript furnizate `setTimeout după anumit număr de milisecunde. Acest lucru este foarte util dacă doriți pentru a permite viewport (ceea ce vezi) pentru a actualiza în timp ce efectuează operațiuni pe ea. Doar looping prin exemplu, coordonatele și actualizarea unui element în consecință, vă va face să vezi începutul și sfârșitul poziții, și nimic în între.


Vom folosi o abstracție în bibliotecă JavaScript, care ne permite de a crea procese și fire care sunt toate gestionate de către același JavaScript interpret. Acest lucru ne permite să executați acțiuni în felul următor:


* Un Proces, Firul 1
* Un Proces, Firul 2
* Procesul B, 1 Fir
* Procesul De O, Fir 3
* Un Proces, Thread 4
* Procesul B, Firul 2
* Pauză De Un Proces
* Procesul B, Fir 3
* Procesul B, Fire 4
* Procesul B, Fir 5
* Începe Un Proces
* Un Proces, Thread 5


Aceasta permite o formă de planificare și falsuri paralelism, pornirea și oprirea de fire, etc, dar nu va fi adevărat multi-threading. Nu cred că va fi vreodată puse în aplicare în limba în sine, deoarece adevarat multi-threading este utilă numai în cazul în care browser-ul poate rula o singură pagină, multi-threaded (sau chiar mai mult decât un singur nucleu), iar dificultățile sunt mult mai mari decât posibilitățile suplimentare.


Pentru viitorul JavaScript, check this out:
[https://developer.mozilla.org/presentations/xtech2006/javascript/](https://web.archive.org/web/20170920070053/https://developer.mozilla.org/presentations/xtech2006/javascript/) Valoarea returnată de o tratare a evenimentului determină dacă sau nu browser-ul implicit comportamentul ar trebui să aibă loc la fel de bine. În cazul clic pe link-uri, acest lucru ar fi urmatoarele link-ul, dar diferenta este cel mai vizibil în formă prezinte stivuitoare, unde puteți anula o formă de transmitere în cazul în care utilizatorul a făcut o greșeală introducerea informațiilor.


Eu nu't cred că există o W3C caietul de sarcini pentru acest lucru. Toate vechi JavaScript interfețe de acest gen au fost dat porecla "DOM 0", și sunt în mare parte nespecificată. Poate ai noroc de lectură vechi de Netscape 2 documentare.


Modul modern de realizare a acestui efect este de a apela eveniment.preventDefault()`, și acest lucru este specificat în [DOM 2 Evenimente caietul de sarcini](https://www.w3.org/TR/DOM-Level-2-Events/events.html#Events-flow-cancelation). Noi folosim [MbUnit](http://www.mbunit.com/) și [Rihno batjocorește](http://www.ayende.com/Blog/archive/2007/03/28/Rhino-Mocks-3.0-Released.aspx) și ei se dovedesc a lucra foarte bine împreună. Când faci TDD va fi aproape sigur nevoie pentru a face o anumită formă de injecție de dependență, în timp ce acest lucru se poate face manual, în valoare de uita la un container IoC , cum ar fi [Castelul Windsor](http://www.castleproject.org/projects/windsor/) .


Este bine în valoare de uita la ecran John Paul Bodhood lui aruncă pentru început. [Blogul lui JPB](http://www.jpboodhoo.com/) **UPDATE**


Acest răspuns este destul de vechi, și așa descrie ceea ce a fost 'bine' la momentul respectiv, care a fost inteligent indicii furnizate de Impuls bibliotecă. Deoarece C++11, biblioteca standard a furnizat suficiente smart pointeri de tipuri, și așa ar trebui să favorizeze utilizarea [`std::unique_ptr`](http://en.cppreference.com/w/cpp/memory/unique_ptr), [`std::shared_ptr`](http://en.cppreference.com/w/cpp/memory/shared_ptr) și [`std::weak_ptr`](http://en.cppreference.com/w/cpp/memory/weak_ptr). 


Acolo a fost, de asemenea, [`std::auto_ptr`](http://en.cppreference.com/w/cpp/memory/auto_ptr). A fost foarte mult ca o luneta pointer, cu excepția faptului că a avut, de asemenea, "speciale" periculoase capacitatea de a fi copiate — care, de asemenea, în mod neașteptat transferă dreptul de proprietate.
**S-a depreciat în C++11 și eliminate în C++17**, deci nu ar trebui't-l folosească.



```
std::auto_ptr<MyObject> p1 (new MyObject());
std::auto_ptr<MyObject> p2 = p1; // Copy and transfer ownership. 
                                 // p1 gets set to empty!
p2->DoSomething(); // Works.
p1->DoSomething(); // Oh oh. Hopefully raises some NULL pointer exception.
```






**RĂSPUNS VECHI**


Un smart pointer este o clasa care se infasoara un 'prime' (sau 'gol') C++ pointer, pentru a gestiona durata de viață a obiectului de a fi subliniat. Nu există nici un singur inteligente de tip pointer, dar toate dintre ele încerca să rezumat o primă pointer într-un mod practic.


Smart pointeri ar trebui să fie de preferat peste prime indicii. Dacă simțiți că aveți nevoie pentru a utiliza pointeri (ia în considerare mai întâi dacă într-adevăr ** face), ar fi normal să doriți să utilizați un smart pointer deoarece acest lucru poate atenua multe dintre problemele cu prime indicii, în principal, uitând să ștergeți obiectul și scurgeri de memorie.


Cu prime indicii, programatorul trebuie să specifice în mod explicit distruge obiectul atunci când acesta nu mai este util.



```
// Need to create the object to achieve some goal
MyObject* ptr = new MyObject(); 
ptr->DoSomething(); // Use the object in some way
delete ptr; // Destroy the object. Done with it.
// Wait, what if DoSomething() raises an exception...?
```

Un smart pointer prin comparație definește o politică ca atunci când obiectul este distrus. Tu încă mai au pentru a crea un obiect, dar nu mai trebuie să vă faceți griji despre distrugerea ei.



```
SomeSmartPtr<MyObject> ptr(new MyObject());
ptr->DoSomething(); // Use the object in some way.

// Destruction of the object happens, depending 
// on the policy the smart pointer class uses.

// Destruction would happen even if DoSomething() 
// raises an exception
```

Cea mai simplă politica de utilizare implică domeniul de aplicare de smart pointer obiect înveliș, cum ar fi puse în aplicare până la [`boost::scoped_ptr`](https://www.boost.org/doc/libs/release/libs/smart_ptr/scoped_ptr.htm) sau [`std::unique_ptr`](http://en.cppreference.com/w/cpp/memory/unique_ptr). 



```
void f()
{
    {
       std::unique_ptr<MyObject> ptr(new MyObject());
       ptr->DoSomethingUseful();
    } // ptr goes out of scope -- 
      // the MyObject is automatically destroyed.

    // ptr->Oops(); // Compile error: "ptr" not defined
                    // since it is no longer in scope.
}
```

Notă: std::unique\_ptr` cazuri nu pot fi copiate. Acest lucru previne pointer de a fi șterse de mai multe ori (în mod incorect). Cu toate acestea, puteți trece referiri la aceasta în jurul valorii de la alte funcții-ai sunat.


`std::unique\_ptr sunt utile atunci când doriți pentru a lega de viata a obiectului la un anumit bloc de cod, sau dacă încorporat ca date membre în interiorul altui obiect, durata de viata de care alt obiect. Obiectul există până conțin bloc de cod este ieșit, sau până la obiect este distrus.


Mai complex smart pointer politică implică numărare de referință indicatorul. Acest lucru permite ca indicatorul să fie copiate. Când ultima "de referință" la obiectul este distrus, obiectul este șters. Această politică este implementată de [`boost::shared_ptr`](https://www.boost.org/doc/libs/release/libs/smart_ptr/shared_ptr.htm) și [`std::shared_ptr`](http://en.cppreference.com/w/cpp/memory/shared_ptr).



```
void f()
{
    typedef std::shared_ptr<MyObject> MyObjectPtr; // nice short alias
    MyObjectPtr p1; // Empty

    {
        MyObjectPtr p2(new MyObject());
        // There is now one "reference" to the created object
        p1 = p2; // Copy the pointer.
        // There are now two references to the object.
    } // p2 is destroyed, leaving one reference to the object.
} // p1 is destroyed, leaving a reference count of zero. 
  // The object is deleted.
```

Referință numărat indicii sunt foarte utile atunci când durata de viață a obiectului este mult mai complicat, și nu este legat direct la o anumită secțiune de cod sau de la un alt obiect.


Există un dezavantaj de referință numărat pointer — posibilitatea de a crea o marionetă de referință:



```
// Create the smart pointer on the heap
MyObjectPtr* pp = new MyObjectPtr(new MyObject())
// Hmm, we forgot to destroy the smart pointer,
// because of that, the object is never destroyed!
```

O altă posibilitate este crearea de referințe circulare:



```
struct Owner {
   std::shared_ptr<Owner> other;
};

std::shared_ptr<Owner> p1 (new Owner());
std::shared_ptr<Owner> p2 (new Owner());
p1->other = p2; // p1 references p2
p2->other = p1; // p2 references p1

// Oops, the reference count of of p1 and p2 never goes to zero!
// The objects are never destroyed!
```

Pentru a rezolva această problemă, atât Stimula și C++11 au definit o `weak_ptr` pentru a defini un slab (nenumărate) de referință la un `shared_ptr`. Am'am avut succes folosind [Mockito](https://github.com/mockito/mockito).


Când am încercat să aflu JMock și EasyMock, am găsit o curbă de învățare pentru a fi un pic abrupt (deși poate că's doar eu).


Îmi place Mockito din cauza naturii sale simple si curate, sintaxa că am fost capabil să înțeleagă destul de repede. Minim sintaxa este conceput pentru a sprijini frecvente cazuri foarte bine, deși de câteva ori am nevoie să fac ceva mai complicat, am găsit ceea ce am vrut a fost susținută și ușor de înțeles.


Aici's o (prescurtată) exemplu de Mockito pagina de start:



```
import static org.mockito.Mockito.*;

List mockedList = mock(List.class);
mockedList.clear();
verify(mockedList).clear();
```

Nu't obține mult mai simplu decât asta.


Singurul dezavantaj major, care mă pot gândi este că nu o't bate joc de metode statice. SpeedDial - acces rapid la site-uri favorite, cu posibilitate de organizare pe domenii; eu folosesc în acest fel 169 de legături; oferă şi un mic preview  

  

DownThemAll - un download manager general, oferă control şi monitarizare mai bune  

  

DownloadHelper - util şi uşor de folosit pentru a descărca conţinut audio/foto/video, mai ales de tip FLASH  

  

GmailNotifier - un notificator pentru multiple conturi de gmail  

  

StatusbarEX - afişează informaţii despre utilizarea memoriei (inclusiv cea consumată de Firefox), a procesorului, viteza reţelei etc  

  

BrowserProtect - întăreşte securitatea la atacuri "hijack"  

  

FasterFox - îmbunătăţeşte performanţa reţelei, la navigare  

  

FlagFox - afişează un mic steguleţ al ţării unde este localizat serverul accesat prin locaţia curentă (dacă reuşeşte o identificare)  

  

AddBlock îl folosesc şi eu de la 1 la 9: 9 cifre  

  

de la 10 la 99 (fiecare număr e compus din 2 cifre): 180 cifre 



  

de la 100 la 999 (fiecare număr e compus din 3 cifre): 2700 cifre



  

de la 1000 la 1024 (fiecare număr e compus din 4 cifre): 100 cifre



  

  

**2989 cifre în total**. Se poate! Nu folosi consolidarea cunostiintelor, din pagina de start mergi direct la capitolul unde crezi ca ai probleme si da click pe subcapitolul respectiv. 
De exemplu, daca vei da click pe culori, vei avea posibilitatea sa recapitulezi culorile: <http://prntscr.com/90vo4g> Apasa [aici](https://www.duolingo.com/comment/14346584) pentru mai multe informatii.