Autor Zpráva
Jcas
Profil *
Po změně módu z quirku na standart přestal správně fungovat script.
Poradíte mi prosím, jak to mám opravit?
Děkuju

http://www.zocschmoravskebranice.eu/index.php?page=galerie
_es
Profil
Jcas:
Pri nastavovaní CSS v JS treba zadávať aj jednotky.
Jcas
Profil *
Jako nějak takto?
object.top = x; na
object.top = x px; nebo takto
object.top = x+" px";
Chamurappi
Profil
Reaguji na Jcase:
Tak, aby výsledný řetězec byl právoplatnou hodnotou vlastnosti top. Co funguje v CSS, bude fungovat i v CSS nastaveném přes JS.
peta
Profil
Jcas:
Délkové jednotky v CSS
Příklad:
div {width: 650px; height: 340px;}

object.top = x; // promenne object.top prirad promennou x
object.top = x px; // nesmysl? co to podle tebe dela? zkus premyslet
object.top = x+" px"; // promenne object.top prirad retezec slozeny z x  a ' px', vysledek treba '650 px', coz je moc hezke, ale v prikladu z css stranky je platna hodnota '650px' a ne '650 px'
object.top mas spravne? Nemelo tam byt object.style.top?

A co priklady na js na jpw, jsi koukal? Tam je to jak? A priklady na google?
JavaScript -- příklady
Treba priklad Jednoducha animace, tam se urcite bude menit pozice objektu
Jednoduchá animace javascriptem
Jcas
Profil *
Podotýkám, že dokud bylo doctype na quirk, tak to fungovalo skvěle. A já si skript nevýmešlel. Použil jsem ho z nějakých příkladů.

Tak stále to není ono. Možná to nesmím napsat, tak jak jsem to napsal.
    set_posun : function (obj, obj2, x) {
    var object = document.getElementById(obj).style;
    var object2 = document.getElementById(obj2).style;
    var px = 'px';
    if (x>120) { 
    object.top = x + px;
    object2.top = x-=120 + px;}   
        else {
        object.top = x + px;
        object2.top = x+=120 + px;}
pako
Profil *
v siedmom riadku dostanes NaN a v desiatom pravdepodobne nejake obrovske cislo. Operator Precedence
Jcas
Profil *
Dost dobře to nechápu (a s tímto mám problém i v php).
vzhledem k tomu, že do sebe peru číslo a řetězec. A css chce řetězec.
V php (většinou to sám neodhalím) na to stačí přetypování proměnné.

Ale abych to shrnul - je to chybný zápis. Stačí, když to dám závorek?
(x+=120) + px
peta
Profil
x = x += 120 + px
x = x += (120 + px)
x = (x+=120) + px
"Stačí, když to dám závorek?" Zkus a uvidis
_es
Profil
Jcas:
x je lokálna premenná funkcie - po skončení funkcie „zahodená“ a teda nemá zmysel na ňu hentak aplikovať operátory += a -=. Prečo nepoužiješ operátory + a -?

V php (většinou to sám neodhalím) na to stačí přetypování proměnné.
V JS je pred sčítaním čísla a textového reťazca číslo automaticky prevedené na textový reťazec.
Jcas
Profil *
Takže naprosto nechápu.
var x = 80;
x  = x + 120;
console.log(x);  // 200

x = 80;
x = x += 120;
console.log(x); // 200

x = 80;
x = x + 120 + 'px';
console.log(x); // 200px

x = 80;
x = (x += 120) + 'px';
console.log(x); // 200px

x = 80;
x = x += 120 + 'px';
console.log(x); // 80120px

var x = 80;
var y = 0;
y = x + 120;
console.log(x);  //80  
console.log(y);  //200

var x = 80;
var y = 0;
y = x += 120;
console.log(x);  //200
console.log(y);  //200
Musím říct, že 5. výsledek naprosto nechápu. Všechny operátory mají zpracování "right to left". Tak bych čekal, že napřed provede součet dvou čísel a potom z nich udělá řetězec a spojí řetězce. Takhle to vypadá jako:
x = (x += 120 + 'px');
-jeden z prvků v závorce je řetezec a proto udělá ze všech tří řetězec
-potom při spojení řetězců mají + a += naprosto stejný význam.Lépe řečeno += je pro práci s řetězci nesmysl a javascript ho zpracuje jako obyč +.
Pochopil jse to? aspoň trochu?

Jenže mi to nesedí, protože u 3. případu opravdu provede napřed sečtení dvou čísel a potop připojení řetězce.
Takže to nechápu. Dle té tabulky mají všechny operátory zpracování z prava do leva. Možná tam bude nějaká priorita zpracování. Jakože + se zpracovává dřív jak =.
Potom by ta 5. varianta by mohla vypadat co se týče zpracování asi takto:
x = x += (120 + 'px');
-Napřed se mi sopjí strig '120px'
-A potom se provádí x+='120px' což už je opět "číslo"+="string" a proto se 80 převede na string.
tady '80120px' a opět se += zpracuje jako obyž + pro zřetězení.
juriad
Profil
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence
napřed se provádí + (ať už jako sčítání čísel nebo spojování řetězců) až o hodně později += (opět ať už jako přičítání čísel nebo připojování řetězců)
Asociativita má význam jen když se provádí víc operací se stejnou prioritou:
1+2+3+4 se vyhodnocuje jako ((1+2)+3)+4

Ano operátor += pro řetězce existuje:
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/String_Operators?redirectlocale=en-US&redirectslug=JavaScript%2FReference%2FOperators%2FString_Operators

5. příklad se vyhodnocuje jako:
napřed spojování: (120 + 'px')
následně připojování a přiřazení (mají stejnou prioritu, tak to půjde zprava doleva)

SSA forma vypadá:
var x = 80;
var t1 = 120 + 'px';
x = x + t1;
x = x;

opraven příklad se sčítáním, měl jsem uzávorkování opačně
Jcas
Profil *
Tyto informace mi stále nesedí pro tento případ.
x = 80;
x = x + 120 + 'px';
console.log(x); // 200px

Dle toho co píšeš, tak měl být také výsledek "80120px"
juriad
Profil
Jcas:
To bude tím, že jsem napsal blbost. Existují dva operátory plus: jeden je unární, druhý je binární.
Unární se píše před číslo a nedělá většinou nic užitečného, používá se jen pro přetypování na číslo: var x = "5"; var y = 7; var z1 = x + y; /*57*/ var z2 = +x + y; /*12*/.
Tato varianta je asociativní zprava doleva: + + +3 = +(+(+(3))), opačně to nedává smysl: (((+)+)+)3. Nejde napsat +++3, to by byl pokus o jiný operátor, který navíc navíc skončí syntax error.
Binární operátor plus je sčítání čísel, nebo spojování řetězců. Ten je asociativní zleva doprava: 1 + 2 + 3 + 4 = ((1 + 2) + 3) + 4, to vysvětluje příklad 3.

Omlouvám se za zmatení.
Jcas
Profil *
No jsem si nevšiml, že jsou dva.
unary + right-to-left
addition left-to-right - Takže tento sčítá?

A pracuje to takto: x = ((x + 120) + 'px');

The unary plus operator precedes its operand and evaluates to its operand but attempts to converts it into a number, if it isn't already. For example, y = +x takes the value of x and assigns that to y; that is, if x were 3, y would get the value 3 and x would retain the value 3; but if x were the string "3", y would also get the value 3. Although unary negation (-) also can convert non-numbers, unary plus is the fastest and preferred way of converting something into a number, because it does not perform any other operations on the number. It can convert string representations of integers and floats, as well as the non-string values true, false, and null. Integers in both decimal and hexadecimal ("0x"-prefixed) formats are supported. Negative numbers are supported (though not for hex). If it cannot parse a particular value, it will evaluate to NaN.

Toto se mi nedaří přeložit, tak abych to pochopil. (Slabá znalost angličtiny)
juriad
Profil
Unární plus předchází své operandy a vyhodnocuje se ke svým operandům, ale snaží se je překonvertovat na číslo, pokud jim už není. Například y = +x vezme hodnotu x a přiřadí ji do y; to jest, pokud x bylo 3, y by dostalo hodnotu 3 a x by zůstalo 3; ale pokud by x byl řetězec "3", y by také dostalo hodnotu 3. Přestože unární negace (-) také může překonvertovat nečísla, unární plus je nejrychlejší a preferovaný způsob konvertování něčeho na číslo, protože neprovádí s tím číslem žádné další operace. Může konvertovat řetězcový zápis celých a desetinných čísel, stejně jako neřetězcové hodnoty true, false a null. Celá čísla v desítkovém i hexadecimálním (šestnáctkovém) zápisu jsou podporována. Záporná čísla jsou podporována (ale ne šestnáctková). Pokud se nepodaří rozparsovat hodnotu, vyhodnotí se jako NaN (Not-a-Number - speciálni hodnota čisla, značící že to číslo není).

Neříká to nic zajímavého, jen popisuje, jaké hodnoty umí konvertovat na čísla a že je to nejrychlejší způsob.

Lze rozdělit operátory pode arity:
unární: +x, -x, ++x, x++, --x, x--, !x, ~x, a pak některé slovní
binární: x.y, x[y], x(y), x*y, x/y, x%y, x+y, x-y, x instanceof y a většína ze zbylých operátorů
ternární, existuje jediný a proto se mu taky tak říká: x?y:z
Jcas
Profil *
Děkuji
Jcas
Profil *
Ještě bych k tomu scriptu měl jednu prosbu. (Odkaz je v prvním příspěvku).
To probliknutí při prvním posunu. Nevíte čím to je prosím.

Když si projedu všechny řádky, tak potom mohu jezdit tam sem jak chci a neproblikává to.
Načtením fotek by to být nemělo. Načítají se dřív, než posouvám.
juriad
Profil
 var img = new Image();        
    img.alt = pole[i];                         //vytvoreni atributu alt
    img.style.border = 0;
    td.href = obrazek;                    //nacteni obrazku
    
    img.onload = function () {            //uprava rozmeru pro <div> ve kterem zobrazime nahled
        var x = img.width;
        var y = img.height;    
        if (x>500) {
            y *= 500; y /= x; x = 500;
           img.width = x;
           img.height = y;    }
          img.style.visibility = 'visible';
           }    
    
   img.src = obrazek;                        //nacteni obrazku
   img.style.visibility = 'hidden';

   this.img = td.appendChild(img);    //vytvoreni potomka = vlozeni elementu <img> do tagu(id) 

Problém je v tom, že obrázek vytvoříš a vložíš do stránky, jenže obrázek se zobrazuje i během načítání. A až je celý načtený, tedy zobrazený ve své skutečné velikosti, tak ho zmenšíš. Sice se to snažíš řešit pomocí visibility, ale ti nefunuje z toho důvodu, že vidibility jen objekt nezobrazí, ale místo mu rezervuje; nezobrazený obrázek těsně před událostí onload způsobí velkou šedou plochu, kterou by potřeboval, kdyby se zobrazit měl.
Buď ho skryj pomocí display: none, nebo ho vlož do stránky až v události onload.

Vaše odpověď

Mohlo by se hodit

Neumíte-li správně určit příčinu chyby, vkládejte odkazy na živé ukázky.
Užíváte-li nějakou cizí knihovnu, ukažte odpovídajícím, kde jste ji vzali.

Užitečné odkazy:

Prosím používejte diakritiku a interpunkci.

Ochrana proti spamu. Napište prosím číslo dvě-sta čtyřicet-sedm: