HTML blink felváltása okosabb javascripttel

Kék lámpa

A blink html tag-gel lehetne villogtatni egy szöveget, de igazából csak firefox-ban működik. És csak a láthatóságot kapcsolta be illetve ki időközönként. Mint mindenre, erre is lehet manapság rengeteg megoldást találni a neten javascripttel. Írtam egyet én is, ami gyakorlatilag bármilyen CSS tulajdonságát képes váltogatni a kiválasztott elemnek. Lehet id és osztály alapján kiválasztani az elemeket. Ezen kívül, ha osztálynév alapján lett megjelölve a villogtatandó tartalom, lehet szűkíteni az elemek listáját egy adott csomópont elemeire. ID ugyebár egy oldalon egyedi kell legyen, így ott nem is lenne sok értelme csomópontra korlátozni. Illetve egy elemre több különböző "blink" is alkalmazható. Majd le is állíthatók.


Lényegében egy javascript osztályról van szó.
blink.js

  1. function Blink(id, ms)
  2. {
  3.         var instance = this;
  4.         var node;
  5.         var state = false;
  6.         var resInterval = 0;
  7.         var oldStyles = new Array();
  8.         var newStyle = arguments.length > 2 ? arguments[2] : {
  9.                 visibility: 'hidden'
  10.         };
  11.         var objs = new Array();
  12.        
  13.  
  14.         var blinkById = function(id)
  15.         {
  16.                 var obj = document.getElementById(id);
  17.                 obj.style.visibility = 'visible';
  18.                 var index;
  19.                 oldStyles.push({});
  20.                 for (index in newStyle)
  21.                 {
  22.                         oldStyles[0][index] = obj.style[index];
  23.                 }
  24.                 objs.push(obj);
  25.         }
  26.        
  27.         var blinkByClass = function(id)
  28.         {
  29.                 //objektumok lekérdezése
  30.                 var all = node.getElementsByTagName('*');;
  31.                 var i;
  32.                 var reg = new RegExp('\\b'+id+'\\b');
  33.                 for (i = all.length-1; i >= 0; i--)
  34.                 {
  35.                         var obj = all[i];
  36.                         if (!reg.test(obj.className))
  37.                         {
  38.                                 continue;
  39.                         }
  40.                         obj.style.visibility = 'visible';
  41.                         var index;
  42.                         for (index in newStyle)
  43.                         {
  44.                                 var os = {};
  45.                                 os[index] = obj.style[index];
  46.                                 oldStyles.push(os);
  47.                         }
  48.                         objs.push(obj);
  49.                 }
  50.         }
  51.  
  52.         instance.blink = function()
  53.         {
  54.                 if (arguments.length)
  55.                 {
  56.                         node = arguments[0].substr ? document.getElementById(arguments[0]) : arguments[0];
  57.                 }
  58.                 else
  59.                 {
  60.                         node = document.getElementsByTagName('body')[0];
  61.                 }
  62.                 if (!resInterval)
  63.                 {
  64.                         var ch = id.charAt(0);
  65.                         if (ch == '.')
  66.                         {
  67.                                 blinkByClass(id.substr(1));
  68.                         }
  69.                         else
  70.                         {
  71.                                 if (ch == '#')
  72.                                 {
  73.                                         blinkById(id.substr(1));
  74.                                 }
  75.                                 else
  76.                                 {
  77.                                         blinkById(id);
  78.                                 }
  79.                         }
  80.                 }
  81.                 var i;
  82.                
  83.                 for (i=objs.length-1; i >= 0; i--)
  84.                 {
  85.                         var tmpStyle = state ? oldStyles[i] : newStyle;
  86.                         var index;
  87.                         for(index in newStyle)
  88.                         {
  89.                                 objs[i].style[index] = tmpStyle[index];
  90.                         }
  91.                 }
  92.                 state = !state;
  93.                 if (!resInterval)
  94.                 {
  95.                         resInterval = setInterval(instance.blink, ms);
  96.                 }
  97.         }                      
  98.        
  99.         instance.stop = function()
  100.         {
  101.                 if(resInterval)
  102.                 {
  103.                         clearInterval(resInterval);
  104.                         resInterval = 0;
  105.                 }
  106.         }
  107. }

Használata:
Először illeszd be a blink.js scriptet.

<script type="text/javascript" src="blink.js"></script>

Majd akár külső javascriptben, akár script tag-ek között jöhet a tartalom kiválasztása. Természetesen csak miután betöltődtek a villogtatandó elemek.
Vegyük a legegyszerűbb verziót, ahol "villogj" id-jű div tartalmát villogtatnánk másodpercenként.

new Blink('villogj',1000).blink();

Az első paraméter az id. A második a villogás sebessége ezred másodpercekben számolva. Az első paraméter megadható még # jellel kezdve is, ha id-ről van szó. Illetve ponttal kezdve, ha osztályról. Ám amennyiben meg van adva a 3. paraméter is, akkor egy asszociatív tömbben lehet felsorolni az új CSS tulajdonságokat. Ekkor a megadott, és az eredetit fogja váltogatni. Például legyen egy bármilyen szöveg kék színűre, majd eredetire változtatva.

  1. new Blink('#szovegid',1000,{
  2.    color: 'blue'
  3. }).blink();

Persze, ha csak a "villogtathato" id-jű diven belüli, "osztaly" osztályú elemeket kell ilyen módon villogtatni, akkor a blink() metódusnak kell átadni paraméterként vagy ezt a csomópontot, vagy az id-jét.

  1. new Blink('.osztaly',1000,{
  2.    color: 'blue'
  3. }).blink('villogtathato');
  1. new Blink('.osztaly',1000,{
  2.    color: 'blue'
  3. }).blink(document.getElementById('villogtathato'));

Le is lehet állítani a villogást. De akkor külön változóba kell tenni az objektumot.

  1. var b = new Blink('#id',500,{
  2.      color: 'blue'
  3. });
  4. setTimeout(b.stop, 3000);

A fenti script 3 másodpercig villogtat. Ez az 500 ezredmásodperces sebességgel 3 (oda-vissza) színváltást jelent.

Most lássuk egyben a fájlokat.
index.html

  1. <html>
  2. <meta http-equiv="content-type" content="text-html; charset=utf-8" />
  3. <style type="text/css">
  4. #egyik {
  5.         visibility: hidden;
  6. }
  7. .villogo {
  8.         color: blue;
  9. }
  10. <script type="text/javascript" src="blink.js"> </script>
  11. <script type="text/javascript" src="init.js"> </script>
  12. </head>
  13.         <span id='egyik' style="color: orange;">Itt egy szöveg</span>, <span class="v1 villogo">ami villog</span>:
  14.                 <div id="villogtathato">
  15.                         <span id='masik' class="villogo v2">villogó szöveg.</span>
  16.                 </div>
  17.         Ez meg nem villog.
  18.  
  19. </body>
  20. </html>

init.js

  1. window.onload = function()
  2. {
  3.         new Blink('#egyik',300).blink();
  4.         new Blink('.villogo',200,{
  5.                 color: 'red'
  6.         }).blink('villogtathato');
  7.        
  8.         new Blink('masik',1000).blink();
  9. }

Demo:

Itt egy szöveg, :

Ez meg nem villog.

Kategóriák: 
Megosztás/Mentés

Hozzászólások

Anonymous képe

Bár én sem vagyok vmi JS zseni még, de tudtommal nem igazán szeretjük az asszociatív tömböket ill. a new kulcsszót

Rimelek képe

Nem tudom, hol hallottad ezeket. Nem a new kulcsszóval van a baj, hanem azzal, aki az osztályát úgy írja meg, mint ahogy én is tettem... vagyis megbíztam benne, hogy mindig new kulcsszóval lesz meghívva a függvény, azaz új példány jön létre és nem a window-nak adom át a tulajdonságokat. De még így sem az a baj, ha használod a new-t, hanem az, ha nem. Amin segíthetsz, ha a konstruktornak szánt függvényben a this-t ellenőrizve szükség esetén magad példányosítod az objektumot és ezzel ugyanazt az eredményt éred el. Persze több módon lehet JS-ben objektumot készíteni. Egyik módja pont az, amikor "asszociatív tömböt" deklarálsz, aminek elemei a metódusok és tulajdonságok. Persze ekkor nem igazán lesznek privát tulajdonságaid. Aztán igen, ott az Object.create metódus. Ami viszont akkoriban, mikor a cikk készült nem igazán volt böngészőfüggetlen. Object.create() browser compatibility

Az objektumok létrehozásának és öröklésének egyszerűsítése volt a cél vele, de ettől még a mai napig teljesen normális, ha azt írod például, hogy var date = new Date();

Anonymous képe

Ja értem, akkor tárgytalan

Új hozzászólás