Исходный код программ встраивается непосредственно в HTML-документ либо загружается из независимых файлов.
Исходный код программ не распространяется с приложением -апплетом. Апплеты загружаются с сервера из независимых файлов.
Программа выкладывается на сервер в виде исходного кода в текстовой форме и в дальнейшем интерпретируется (без предварительной компиляции) браузером после загрузки ее с сервера.
Программа компилируется в машинно-независимый байтовый код Java-код, после чего выкладыватся на сервер. Браузер (виртуальная Java-машина) исполняет Java-код.
Объектный. Можно программировать как без использования объектного программирования, так и используя предопределенные встроенные классы. Имеется теоретическая возможность расширения этих классов, но реально она никогда не используется.
Объектно-ориентированный. Программировать без использования объектного программирования нельзя. Апплеты состоят из классов с возможностью иерархического наследования по традиционной схеме наследования. Использование наследования и полиморфизма – основа программирования в Java.
В отличие от подавляющего большинства языков объектного программирования в JavaScript структура объектов не задается однозначно устройством класса, а является динамической и может меняться на этапе выполнения программы. Объекты могут динамически получать новые поля и методы или изменять любые параметры старых.
Структура объектов полностью задается на этапе компиляции их классов.
Свободная типизация: элементарные типы данных переменных не описываются, при присваивании тип левой части всегда определяется по результату присваивания (т.е. по правой части)
Строгая типизация: типы данных любых переменных должны быть описаны перед использованием, тип левой части должен совпадать с типом правой (за редкими исключениями, когда работает автоматическое приведение типа результата к типу левой части)
Статическое связывание кода с объектами: ссылки на объекты должны существовать на момент компиляции
Основные типы данных
Значения переменных, функций и выражений бывают следующих типов:
целые численные:
в десятичной системе единиц: 0, 29, 70, -147 и т.п.;
в 16-ричной: 0х70 или 0х70, 0XFA7D0 и т.п.;
в 8-ричной: 070, 0710 (Внимание!!! Ведущий ноль воспринимается как символ 8-ричного числа) и т.п.
вещественные численные:
0.0, -2.9, 0.7E1, 14.7e-2, 1e+308 (максимальное вещественное число), 1.001e-305 (минимальное по модулю вещественное число, отличное от нуля) и т.п.;
логические (булевские): true и false;
строковые: "Привет, все!", "ОК", 'Слово "Привет!" с кавычками внутри строки', "Другой вариант 'Привет' с кавычками внутри строки" и т.п. (допускаются оба типа кавычек и многократное использование таких пар внутри друг друга). Специальные символы обозначаются комбинацией символа \ и буквы (или последовательности цифр), например: \b — "забой", \n — перевод на новую строку, \" — "кавычка".
null — специальное значение для обозначения “пустого множества” значений.
Переменные. Приведение типов
Глобальные переменные можно вводить в любом месте текста программы путем простого присваивания значения. Но необходимо, чтобы переменная была определена до того момента, когда вызывается при исполнении:
var myVariable=0.1
var B=false
и т.п. При этом тип переменной приводится к типу присваиваемого значения, причем в последующем этой же переменной можно присвоить значение другого типа:
myVariable="Теперь это текстовая переменная"
При задании переменной использование зарезервированного слова var не обязательно, но желательно, т.к. помогает при использовании отладчика фирмы Microsoft и делает текст программы более структурированным. На деле вместо переменной в текущем объекте window создается новое поле с таким именем. В функциях при задании локальных переменных использование var обязательно (иначе будет создана глобальная переменная).
При наличии численных и строковых значений в одном выражении идет приведение к строковому типу. Значением переменной
a=7+"раз отмерь,"+1+"раз присвой"
будет строка "7 раз отмерь, 1 раз присвой".
Стоит отметить, что существуют также функции parseFloat и parseInt, которые осуществляют преобразование из строкового значения в численное.
Идентификатором переменной может быть последовательность символов из набора букв от "A" до "Z", от "a" до "z", цифр от "0" до "9", а также символ подчеркивания "_". При этом первым символом имени не может быть цифра, а заглавные и строчные буквы отличаются (т. е. имена MyVariable и myvariable относятся к разным переменным).
Кроме глобальных переменных в функции или другом блоке кода можно определить локальные, для них областью видимости будет только функция (без кода), в которой они определены:
var myLocalVariable=0.
SCRIPT-вставки в HTML-документе
Для встраивания программы на JavaScript в HTML — файл используются теги . При этом результат работы можно увидеть сразу и при необходимости внести изменения.
It was dynamically created text.
The end
.
Операторы, выражения, функции Операторы: арифметических действий, присваивания, инкрементные, декрементные. Условные выражения
Операторы арифметических действий в JavaScript те же, что и в С и Java:
Сложение "+", вычитание "-", умножение "*", деление "/", остаток от целочисленного деления "%".
Эти операторы могут встречаться в любом численном выражении. (Внимание! Они также могут встречаться в строковых выражениях в случаях, когда используется автоматическое приведения чисел в строки ).
Операторы присваивания в JavaScript те же, что и в С и Java:
"=", "+=", "-=", "*=", "/=", "%="
x=y, как и в большинстве других языков, значит присвоить переменной "х" значение переменной "y".
Следующие операторы имеют синтаксис, сходный с синтаксисом соответствующих операторов языка С:
y+=x эквивалентно y=y+x
y-=x эквивалентно y=y-x
y*=x эквивалентно y=y*x
y/=x эквивалентно y=y/x
y%=x эквивалентно y=y%x – остаток от деления нацело y на x.
Условное выражение имеет вид
(условие)?значение1:значение2
Если значение условия true, значением условного выражения будет значение1, иначе — значение2. Условное выражение можно применять везде, где можно применять обычные выражения.
Пример:
a=(b<1)?0:(x-1)+c
Инкрементные и декрементные операторы также имеют синтаксис, заимствованный из языка С: "х++", "++х", "х--", "--х".
Выражения:
y=x++ эквивалентно двум присваиваниям: y=x; y=y+1,
y=++x эквивалентно двум присваиваниям: x=x+1; y=x,
y=x-- эквивалентно двум присваиваниям: y=x; x=x-1,
y=--x эквивалентно двум присваиваниям: x=x-1; y=x.
Строковые операции
Существуют ряд операторов работы со строками:
"+" - сложение (конкатенация) строк s1+s2 дает строку, состоящую из последовательности символов строки s1, за которыми следуют символы строки s2.
eval(s) - встроенная функция JavaScript. Она выполняет код, заданный аргументом— строкой s, который может содержать один или более операторов JavaScript (через точки с запятой). Данную функцию можно использовать не только для выполнения оператора, но и для вычисления выражения. Она возвращает значение последнего вычисленного выражения в заданном коде. Функция eval(s) обеспечивает возможность вычислять значения, введенные пользователем в пункты ввода, а также динамически модифицировать выполняемый код в JavaScript-программе. Более общая, чем функции parseInt и parseFloat.
parseFloat(s) – встроенная функция JavaScript. Находит содержащееся в строке s вещественное число (типа Float ) от начала строки до первого символа, не входящего в число. Если число не найдено, возвращает значение NaN (“Not a Number”)
parseInt(s) – то же для целых чисел (Integer). При этом автоматически находится основание.
parseInt(s,n) – то же для целых чисел по основанию n (от 2 до 36). При n=0 – то же, что parseInt(s). При этом автоматически находится основание
Побитовые операции присваивания
Существуют ряд операторов побитового присваивания:
х<<=n эквивалентно x=(x<числа x;
x>>=n эквивалентно x=(x>>n )— сдвиг на n битов вправо двоичного представления целого
числа x с сохранением знакового бита (отрицательные
числа в дополнительном коде имеют первым битом
единицу. После сдвига на место первого бита записывается
1, и число остается отрицательным);
x>>>=n эквивалентно x=x>>>n — сдвиг на n битов вправо двоичного представления
целого числа x с ведущим нулем 0 (После сдвига на место
первого бита записывается 0, и число становится
положительным);.
Всё выражение (у нас — "x") в левой части преобразуется в 32-битное целое число, после чего производится необходимый сдвиг, а затем получившиеся число приводится к типу выражения – результата (у нас это опять"x"), и производится присваивание.
Примеры:
1) 9<<2 дает 36, т.к. сдвиг 1001 (число 9 в двоичном представлении) на 2 бита влево
дает 100100, т.е. 36. Недостающие биты заполняются 0.
9>>2 дает 2, т.к. сдвиг 1001 (число 9 в двоичном представлении) на 2 бита вправо
дает 10, т.е. 2. Недостающие биты заполняются 0.
"&" — побитовая AND — "И";
"|" — побитовое OR — "ИЛИ";
"^" — побитовое XOR — "ИСКЛЮЧАЮЩЕЕ ИЛИ".
Все операции совершаются с двоичным представлением чисел, однако, результат возвращается в обычном десятичном представлении.
Примеры:
15&9 возвращает 9, т.к. (1111) AND (1001) равно 1001;
15|9 возвращает 15, т.к. (1111) OR (1001) равно 1111;
15^9 возвращает 6, т.к. (1111) XOR (1001) равно 0110.
2.3 Логические выражения.
"&&" — логическое AND — "И";
"||" — логическое OR — "ИЛИ";
"!" — логическое NOT — "НЕ".
Пример:
(a>b)&&(b<=10)||(a>10)
В JavaScript всегда применяется так называемая сокращенная проверка логических выражений: в операнде B1&&B2 при B1=false оценки B2 не производится и возвращается значение false. Аналогично B1||B2 при B1=true оценивается как true. При этом анализ логического выражения идет слева направо, и как только всё выражение может быть оценено, возвращается результат. Поэтому, если в качестве B2 выступает функция, она не будет вызываться, и если она должна давать побочные эффекты, то это может привести к ошибке.
Операторы сравнения
"= =" -"равно";
">" -"больше";
"<" -"меньше";
">=" -"больше или равно";
"<=" -"меньше или равно";
"!=" -"не равно".
Операторы сравнения применимы не только к численным, но и к строковым выражениям. При этом строки считаются равными, если все их символы совпадают и идут в одном и том же порядке (пробел учитывается как символ). Если строки разной длины, то большей будет строка имеющая большую длину. Если их длины совпадают, больше считается та, у которой при просмотре слева направо встретится символ с большим номером
(a < b < c < .... < z < A < ... < Z).
Строки можно складывать, если S1="это ", S2="моя строка", то S1+S2 даст "это моя строка".
Приоритет операторов (начиная с младших; в одной строке старшинство одинаково):
"+=", "-=", "*=", "/=", "%=", "<<=", ">>=", ">>>=", "&=", "^=", "|=".
Старшинство операций
В JavaScript, как и в С или Java, процедуры и процедуры — функции называются функциями. Декларация функции состоит из:
зарезервированного слова function;
имени функции;
списка аргументов, разделенных запятыми, в круглых скобках;
тела функции в фигурных скобках.
function myFunction(arg1, arg2, ...)
{
...
последовательность операторов
...
}
где myFunction — имя функции, arg1, arg2 — список формальных параметров
Пример:
function Factorial(n)
{
if((n<0)||(round(n)!=n))
{
alert("функция Factorial не определена при аргументе "+n);
return NaN;
}
else
{
result=(n*Factorial(n-1));
return result;
}
}
Функция может не возвращать значения с помощью зарезервированного слова return.
Пример:
function Greeting(s)
{document.write("Hello,"+s+"!");
}
Вызов функции производится с фактическими параметрами.
Пример:
Factorial(2+1);
— внутри некого выражения возвратит 6, а
Greeting("world");
—приведет к выводу на экран строки "Hello, world!".
Каждая функция, например myFunction, является объектом с именем myFunction, аргументы которого хранятся как массив, имеющий имя arguments, при этом доступ к аргументам может осуществляться так:
myFunction.arguments[i], где i — номер аргумента (нумерация начинается с 0).
Число фактических параметров должно быть равно либо больше числа формальных параметров в описании функции. При этом, при вызове функции действительное число переданных аргументов хранится в поле myFunction.arguments.length и может динамически изменяться переприсваиванием значения этого поля.
Пример:
Вывод в документе списка в формате HTML.
Первый аргумент здесь (ListType) может иметь значение "о" или "О" для упорядоченного списка и "u" или "U" для неупорядоченного. Далее идут элементы списка.
function myList(ListType)
{
document.write("<"+ListType+"L");
for(var i=1; i < myList.arguments.length; i=i+1)
{document.write("
"+myList.arguments[i]);
}
document.write(""+ListType+"L>");
}
Вызов в тексте HTML документа этой функции:
приведет к выводу текста:
один
2
3
Условный оператор if
первый вариант синтаксиса оператора if:
if(условие)
{
утверждение
}
(Утверждением называется оператор или последовательность операторов.)
b) второй вариант синтаксиса оператора if:
if(условие)
{
утверждение1
}
else
{
утверждение2
}
Пример использования условного оператора:
function checkData()
{
if (document.form1.threeChar.value.length==3)
{return true;
}
else
{alert('Введите ровно 3 символа');
return false;
}
}
Цикл for
for(секция инициализации; секция условия; секция изменения счетчиков)
{
утверждение
}
Каждая из секций может быть пустой. В секциях инициализации и изменения счетчиков можно писать последовательности выражений, разделяя их запятыми. Выполнение цикла происходит следующим образом. Первой выполняется секция инициализации. Затем проверяется условие. Если условие равно true, то выполняется тело цикла, а затем секция изменения счетчиков. Если условие равно false, то выполнение цикла прекращается.
Пример :
function HowMany(SelectObject)
{
var numberSelected=0
for (i=0; i< SelectObject.options.leght; i++)
{
if (SelectObject.options[i].selected==true) numberSelected++;
}
return numberSelected;
}
Оператор for может использоваться для перебора всех полей объекта (см. далее раздел про объектную модель)
Синтаксис:
for(переменная in объект)
{
выражение
}
При этом производится перебор всех возможных значений указанной переменной в объекте, и для каждого из них выполняется утверждение.
Пример:
function student(name, age, group)
{
this.name=name;
this.age=age;
this.group=group;
}
function for_test(myObject)
{
for(var i in myObject)
{
document.write("i="+i+" => "+myObject[i]+"/n");
}
};
Helen=new student("Helen K.", 21, 409);
for_test(Helen);
Вывод на экран:
i=0 => Helen K.
i=1 => 21
i=2 => 409
Цикл while
while(условие)
{
выражение
}
Выполнение цикла while начинается с проверки условия. Если оно равно true, то выполняется тело цикла, иначе управление передается оператору, следующему за циклом.
Пример использования оператора while:
n1=10
n=0
x=0
while(n{
n=n+1;
x=x+n;
}
2.8 Операторы прерывания выполнения циклов.
Для прекращения выполнения текущего цикла операторов for или while служит оператор break.
Пример использования оператора break:
function test(x)
{
var j=0;
var sum=0;
while(n{
if(n==x)
{ sum=x;
break;
}
sum=sum=n;
n=n+1;
}
return sum;
}
Оператор continue прерывает выполнение текущей итерации внутри for или while и вызывает переход к началу следующей итерации.
Пример использования оператора continue:
function test1(x)
{
var j=0;
while(n{ if(n==x)
{ sum=x;
continue;
}
sum=sum=n;
n=n+1;
}
return sum;
}
Объектная модель Классы, объекты, поля данных, методы
Подробная теоретическая информация по этому разделу содержится в курсе “Объектно - Ориентированное Программирование”. Отметим только, что класс – это тип данных, в котором описывается, как должны быть устроены переменные данного типа – объекты.
JavaScript существует большое число предопределенных классов. Также можно определять собственные классы. Однако возможность создания в JavaScript собственных классов носит итсключительно рекламно-декоративный характер: трудно представить ситуацию, когда она реально может понадобиться. До сих пор ни на одной WWW-странице нам такая ситуация не встретилась.
Работа с полями данных и методами уже существующих объектов
В JavaScript доступ к полям данных и методам может быть осуществлен обычным путем через квалификацию имени: если Data1 — поле данных, а method1 — метод объекта obj1, то obj1.Data1 означает доступ к полю Data1 этого объекта, а obj1. method1 — вызов его метода method1 (напомним, что Data1 и data1 — разные идентификаторы, как и method1 и Method1, и т.п.). Для определенных в программе объектов доступ может
быть как по чтению, так и по записи. Ряд полей предопределенных объектов доступны только по чтению ( например, Math.PI- значение числа "пи"). Если до присваивания поля данных
с используемым именем его в объекте не было, оно динамически создается в момент присваивания.
Пример:
student.name="Алексей Иванов";
student.age=26;
student.group=409;
a=student.name
Возможен второй путь доступа к полям данных — ассоциативный, через массив индексов:
student["name"]="Алексей Иванов";
student["age"]=26;
student["group"]=409;
b=student["group"]
Возможно определить поле данных объекта только через индекс, без имени. В этом случае доступ к полю будет возможен только по номеру:
A[0]=1; A[1]=2; A[2]=4;
B[0]="a"; B[1]="b" ;
и т.д. Подобного рода поля — это массив, но в отличие от массивов в других языках программирования его элементы могут иметь произвольный тип.
Задание метода myMethod объекта myObject может быть произведено либо
"изнутри"(в определенный класс- смотри далее), либо "снаружи"-простым присваиванием:
myObject.myMethod=myFunction;
где myFunction — имя уже определенной функции. Допустим, это myGreeting. Тогда myObject.myMethod=myGreeting;
Вызов методов осуществляется аналогично вызову обычной функции JS. Метод может использоваться как процедура:
myObject.myMethod("method");
даст "Hello, method!"
Либо же можно использовать метод как собственно функцию, возвращающую значение.
Для создания нового класса объектов (например, student) надо определить функцию с таким именем. Вместо имени объекта для доступа к полям внутри этой функции надо использовать зарезервированное слово "this".
Задание нового класса объектов. Квалификатор this
Процедура определения класса student:
function student(name, age, group)
{
this.name=name;
this.age=age;
this.group=group;
}
В соответствии с правилами JavaScript мы фактически ввели глобальные переменные
student.name, student.age, student.group.
Теперь можно определить объекты типа student с помощью предопределенного слова new:
Paul=new student("Павел", 23, 509);
Alex=new student("Алексей", 26, 609);
Объекты- это экземпляры класса. Может быть сколько угодно экземпляров данного класса и
При необходимости можно менять параметры существующих экземпляров и создавать новые.
Следует отметить, что в зависимости от фактического списка параметров поля объектов "student" могут иметь разные типы. Более того, даже число полей, как мы знаем, может быть разным при соответствующем определении функции.
Операторы for и with для работы с объектами
вставить for..in…
Для получения доступа к полям объекта очень удобен оператор with. Его синтаксис таков:
with(объект)
{
утверждение
}
Внутри тела оператора with (т.е. в утверждении) методы и переменные, по умолчанию квалифицируются именем объекта (без явного указания в качестве префикса имени объекта
С последующуй точкой), если нет локальных методов или переменных с использованными именами. Если имеются локальные методы или переменные объекта с тем же именем, доступ к полям, как мы уже знаем, должен осуществляться "извне" через полное имя ( с явной квалификацией) , а "изнутри" объекта - с помощью квалификатора this.
Пример:
var x,y;
with(Math)
{
y=PI/2;
x=sin(y/7)+pow(y,2);
}
Здесь вместо PI, sin и pow используются поле и методы объекта Math:
Math.PI
Math.sin
Math.pow
Правила работы с объектами
Объекты можно передавать в функции в качестве параметров. Например, если мы имеем следующее определение функции IndividualPlan:
function IndividualPlan(student, yearCount)
{
this.person=student;
this.year=yearCount;
}
То
PaulPlan=new IndividualPlan(Paul,5);
создаст объект с именем PaulPlan, поле PaulPlan.person которого является объектом типа student. При этом доступ к имени студента будет производиться следующим образом:
PaulPlan.person.name.
Отдельному объекту можно динамически добавлять поля:
Paul.award="Грант Шведского института"
При этом у остальных объектов типа student этого поля не будет. Аналогично добавляются методы, так так можно динамически переприсваивать методы объекта. Например, если функцию IndividualPlan определить сначала как
function IndividualPlan(student, yearCount)
{
this.person=student;
this.year=yearCount;
this.hello=myGreeting;
}
то вызов
PaulPlan.hello("University");
приведет к выводу на экран следующей строки:
"Hello, University!"
В любой момент в программе можно переопределить функцию IndividualPlan.hello.
Например, введем функцию ShowPerson, не имеющую параметров:
function showPerson()
{
document.write("Владелец индивидуального плана "+this.person.name);
}
после чего проведем присваивание
IndividualPlan.hello=showPerson;
Оно изменит не только тело функции, но и число ее аргументов. Теперь вызов
PaulPlan.hello();
приведет к выводу на экран
Владелец индивидуального плана: Павел.
В JS все элементы кроме операндов и операторов являются объектами. Поэтому для них можно вызывать соответствующие методы. Имена предопределенных объектов начинаются с большой буквы. Так при вызове методов для строковой переменной или строкового выражения вызываются методы встроенного объекта Stung.
Динамическое формирование документа