Виды операторов в JavaScript

Назначение операторов


  Share  
|


Ключевые задания оператора является знак равенства (=). Левый операнд является переменной, массив элемент, или объект собственности, а также право операнда либо буквальное или иной переменной, массив элемент, или объект собственности. Назначение переменная величина может быть выполнена с любого числа различных комбинаций переменных, массив элементов, свойства объекта, а также литералы.

Ниже приводится идея спектр заданий: 

  альфа = 77;  
  альфа = (fishSize.length / 2);  
  альфа = (бета> гамма);

Подворье Операторы

Операторы, которые включают задания вместе с эксплуатации комплекса операторов. Эти работать операторам, как сокращенную по уступке плюс еще одна операция. Например: 

  VAR bankAccount + = интересов;

это в письменной форме эквивалент 

  VAR bankAccount = bankAccount + проценты;

Кроме того, соединение операторов в JavaScript включить вычитать присвоить (-=), умножить присвоить (*=), разделить присвоить (/ =), а также модули назначать (% =). Например, следующий сценарий использует модуль соединения оператора уступку: 

 <html>  
 <head>  
  <script language="JavaScript">  
  VAR болты = 150, лот = 60;  
  болты% = много;  
  document.write ( "Странное много =" + болты);  
  </ скрипт>  
  </ HEAD>  
  <body bgcolor="lightslategray">  
  </ BODY>  
  </ HTML>

В качестве примера показано, как две операции могут быть объединены в один. Переменная болты, делится на значение переменной много, а остальные (по модулю) присваивается переменной болтов. Было бы то же, как написание этого: 

  VAR = болтов болты% партии;

Однако, вместо того, две операции, одна уловка делает уступки и эксплуатации.

Сравнение операторов

Наверное области наиболее ошибок в JavaScript с операторами путаницу (или просто забыть) различие между уступкой операторы и операторы сравнения. Назначение операторов отождествлять ценность с переменной массив элемент, или объект собственности. Сравнение операторов генерировать булевых значения. Например, следующий сценарий возвращает ложное булевы значения: 

 <html>  
  <script language="JavaScript">  
  VAR неправильно = (6 == 7)  
  document.write (неправильно);  
  </ скрипт>  
  <body bgcolor="lightslategray">  
  </ BODY>  
  </ HTML>

Оператор сравнения двойную знак равенства (= =), а также назначение оператора равна (=) знак. Наиболее распространенной проблемой является стандартом условное заявление, в котором разработчик типы это: 

  если (= альфа-бета) (.... WRONG

, когда он виду по типу этого: 

  если (альфа-бета-==) (....  ПРАВО

В процессе отладки, одна из первых вещей для поиска является размещение задания оператора, где равенство оператора должно быть.

Другие операторы сравнения включают в себя не равны (! =) Меньше (<), больше (>), меньше или равно (<=), а больше или равно (> =). Как и равенство оператора, эти другие операторы сравнения двух ролей. Одна из задач является частью условное заявление, а другая заключается в том, чтобы служить в качестве булева литералы в определениях, как и в предыдущем примере показал. Следующий сценарий показывает, как переменные могут быть определены так, что они могут содержать булевой литералы, а затем используется как часть условно заявление без использования операторов сравнения: 

 <html>  
  <script language="JavaScript">  
  VAR альфа = 25;  
  VAR бета = 35;  
  VAR дзета = (альфа <= бета);  
  если (дзета) ( 
       VAR сигма = "Это верно".  
       () Другое 
       VAR сигма = "Это не соответствует действительности.";  
       )  
  document.write (сигма);  
  </ скрипт>  
  <body bgcolor="lightslategray">  
  </ BODY>  
  </ HTML>

В этом сценарии переменный альфа сравнению быть меньше или равно (<=) бета-версии в определении дзета. Поскольку альфа меньше, чем бета-версия, переменными дзета содержит булевы значения верно. В условное заявление, никаких сравнительных операторов используются потому, что переменная бета уже булевых значения. Поскольку стоимость можно сказать, что он соответствует условию, чтобы загрузить с переменной Sigma сообщение: "Это верно".

Строгое равенство операторов

JavaScript 1,3 представил строгого равенства и неравенства операторов. Эти операторы испытание для обоих равенства ценности и равенства типа. Иными словами, если оба значения были 23, но одна переменная строка, а другая представляет собой число, вы, возможно, думают, что они будут неравными в любом случае. Рассмотрим следующий сценарий: 

 <html>  
  <script language="JavaScript">  
  VAR currentWord = "75";  
  VAR currentNumber = 75;  
  VAR результат = (currentWord == currentNumber);  
  document.write (результат);  
  </ скрипт>  
  <body bgcolor="lightsalmon">  
  </ BODY>  
  </ HTML>

Вы можете быть удивлены тем, что переменная результата верно! Причина этого заключается в том, что JavaScript пытается очень трудно решить числовые комбинации и различия. Помните, если вы определяете переменную следующим образом, результат является строкой, даже несмотря на то, что линия смеси цифровым и строка литералов: 

  VAR сочетание = "$" + 12,33;

То же самое, когда JavaScript сравнение двух переменных, где один номер и одна строка. Если "ценности", как считается, быть таким же, даже если одна строка, а другая представляет собой число, JavaScript helpfully делает их равными, как это было в предыдущий сценарий. Однако, если у вас приложение, в котором обе ценностям и введите данные имеют важное значение для сравнения, можно не делать, что сравнение со стандартным сравнение операторов. Чтобы решить эту проблему, JavaScript 1,3 представил строгого равенства (===) и неравенства (! ==) Операторов. Эти операторы с нетерпением не только ценности, но и на тип переменной. В предыдущий сценарий, измените эту строку: 

  VAR результат = (currentWord == currentNumber);

к 

  VAR результат = (currentWord === currentNumber);

Затем сохраните скрипт и запустить программу снова. Во второй версии сценария, результат изменений в ложными. Несмотря на то, что номера те же, данные различных типов. Чтобы получить подлинный результат, измените строку в следующих случаях: 

  VAR результат = (currentWord! == currentNumber);

И Netscape Navigator 4.7 и Internet Explorer 5, а затем признать, строгое равенство и неравенство операторов. (Версии 4 Netscape Navigator требует язык = JavaScript1.2 в <script> тег, но в более поздних версиях браузера, все что вам нужно это язык = JavaScript.)

Арифметические операторы

Основные арифметические операторы в JavaScript достаточно разъяснений, с некоторыми исключениями. Для того чтобы избежать обострения несколькими из этих исключений, каждый оператор обсудил с упором на использование.

Добавить и связывать (+)

Один из арифметических оператора, который использует два различных добавить (+). Во-первых, добавить оператор добавляет ценности в математике операций. Во-вторых, она concatenates (вместе) строки или строк и другие литералы. Математическое дополнение является достаточно простым, но это не стечение. Если добавить операции присоединяется строки и числа, то concatenates их и преобразует число в строку. Например, следующий сценарий вместе со строками nonstring литералы: 

 <html>  
 <head>  
  Добавить <title> и связывать </ TITLE>  
  <script language="JavaScript">  
  VAR Boole = 22 <90;  
  VAR строка = "250";  
  VAR numnum = 88;  
  VAR BooleNum = Boole + numnum;  
  VAR BooleString = Boole + строка;  
  VAR StringNum = строка + numnum;  
  VAR PART1 = "Булевы значения <b>" Boole + + "</ B>, а также номер" numnum + + "=" +  
Graphics / ccc.gif BooleNum;  
  VAR PART2 = "<p> булевы значения <b>" Boole + + "</ B>, а также строка" + строка + "=" +  
Graphics / ccc.gif BooleString;  
  VAR part3 = "<p> строковое значение <b>" + строка + "</ B>, а также номер" numnum + + "=" +  
Graphics / ccc.gif StringNum;  
  document.write (PART1 + PART2 + part3);  
  </ скрипт>  
  </ HEAD>  
  <body bgcolor="paleturquoise">  
  </ BODY>  
  </ HTML>
Вычтите и отрицания (-)

Знак минус (-) имеет два очень разных целях. Во-первых, в арифметических операций, вычитание оператор вычитает второй операнд из первого. Таким образом, эта линия мест стоимостью 7 в альфа-переменную: 

  VAR альфа = 10-3;

Во-вторых, использоваться как унарные оператор, знак минус изменения позитивно оценивать отрицательное значение. Кроме того, в случае отрицательного значения вычитается из положительное значение, результат будет такой же, как добавляя двух положительных значений. Следующий сценарий иллюстрирует использование унарные отрицания и вычитания с минус (-) знак как оператор. Например, попробуйте следующий сценарий и посмотреть, если вы можете определить заранее, какие результаты будут: 

 <html>  
 <head>  
  <title> знак минус и отрицательные значения </ TITLE>  
  <script language="JavaScript">  
  VAR posVal = 44;  
  VAR negVal =-posVal;  
  VAR diffVal = (posVal-negVal);  
  document.write (diffVal);  
  </ скрипт>  
  </ HEAD>  
  <body bgcolor="papayawhip">  
  </ BODY>  
  </ HTML>

Если вы догадались, что вывод на экран будет 88, вы правы. Положительное значение в переменной posVal 44. Переменная negVal создана унарные отрицание posVal. Когда negVal вычитается из posVal, эффект заключается в том, чтобы добавить два значения. (Точно так же, как в грамматике, двойной негативный создает положительный.)

Умножьте (*)

Оператор умножения прост-он умножает два числа. Однако, если попытаться умножить две строки, содержащие цифры, символы, JavaScript пытается изменить строки в номер и полный размножения. Например, попробуйте следующий сценарий: 

 <html>  
 <head>  
  <title> Умножьте Числа в строках </ TITLE>  
  <script language="JavaScript">  
  VAR stringNum = "5";  
  VAR stringNum2 = "20";  
  VAR mulEm = stringNum * stringNum2;  
  document.write (mulEm);  
  </ скрипт>  
  </ HEAD>  
  <body bgcolor="peru">  
  </ BODY>  
  </ HTML>

Вывод на экран будет 100. Таким образом, оператор умножения (*), могут на самом деле преобразования некоторых строк в номер, а также умножать цифры.

Разделить (/)

Как размножаются оператор, оператор пропасти (/) работает с числами. В операции, левый операнд делится на право операнда. Кроме того, как размножаются операторов, пропасть оператор пытается преобразовать строку в число. Область, где разделение отличается от большинства других операций в пропасть к нулю ошибки. Два разных типов возвращает результат. Разделить на ноль из числа кроме 0 результатов в бесконечность, в то время как ноль разделить на ноль возвращает NaN. Следующий сценарий демонстрирует, что прибыль от обоих типов разделить на ноль ошибок. Кроме того, сценарий показывает, как использовать встроенные функции isFinite () и isNaN () для проведения испытаний на бесконечность и Нан ценностей. В случае бесконечности, isFinite () функция должна быть на нет использование! Оператора.

Для дизайнера, важно знать, если разделить на ноль инстанции происходит так, что вы можете сохранить его от сбой вашей программы. Дома-квартиры сайте, например, модуль, который вычисляет сумму красок, необходимых для краской номера. Галлон краски охватывает 350 квадратных футов. Итак, где-то в калькулятор, дизайнер должен иметь формулу, которая делится на 350 квадратных футов в помещении окрашены время. Предположим, что зритель забыл войти стоимости квадратного фута в комнату и сценарий пытались разделить 350 на 0. Вместо того чтобы отправить зрителя в путаницу, сообщив ей, что она для приобретения бесконечного количества галлонов краски, вы можете ловушки, чтобы разделить на ноль ошибок и отправить любое сообщение, что вы хотите, как это иллюстрирует следующий сценарий: 

 <html>  
 <head>  
  <title> разделить на ноль Ошибки </ TITLE>  
  <script language="JavaScript">  
  VAR leftOperand = 77;  
  VAR rightOperand = 20> 30;  
  VAR divEm = leftOperand / rightOperand;  
  Надо VAR = 0 / 0;  
  document.write (divEm + "<p>" + Nada);  
  если (! isFinite (divEm)) ( 
  оповещение ( "Вау Чувак, что \" SA большое число! ")  
  )  
  если (isNaN (Nada)) ( 
  Оповещение ( "Вы ничего не путем деления ничего".)  
  )  
  </ скрипт>  
  </ HEAD>  
  <body bgcolor="springgreen">  
  </ BODY>  
  </ HTML>
Модулю (%)

Модулю (%) оператор возвращает остаток в отдел эксплуатации. Левый операнд делится на право операнда, и только оставшаяся возвращается. Несмотря на то, что модуль оператора не приходит на ум в большинстве приложений, она может оказаться чрезвычайно полезным оператора. Например, следующий сценарий использует оператор конвертировать долго после запятой на два места после запятой.

modulo2dec.html 
 <html>  
 <head>  
  <title> модулю два знака после запятой преобразователь </ TITLE>  
 <style>  
  (тело 
  -цвет фона: сливы;  
  семейство шрифтов: Verdana;  
  начертание шрифта: жирный;  
  )  
  </ стиль>  
  <script language="JavaScript">  
  VAR декабря =. 06;  
  VAR часть = 77,4;  
  часть + = (* Декабрь часть);  
  VAR wholeInt = Math.floor (частично);  
  / / The Math.floor () функция раундов переменной "части" вниз до ближайшего целого.  
  / / До получения модуль (далее) "участие" времен 100 округлены до  
Graphics / ccc.gif  ближайшего целого получить целое остальные.  
  VAR часть = Math.round (часть * 100)% 100;  
  если (часть <10) ( 
  часть = "0" + фракцию;  
  )  
  VAR fullVal = wholeInt + "."  + Фракцию;  
  VAR headTitle = "<h2> модулю помощнике </ h2>"  
  VAR до = "До преобразования =" + часть + "<p>";  
  после VAR = "После преобразования =" + fullVal;  
  document.write (headTitle + до + после);  
  </ скрипт>  
  </ HEAD>  
 <body>  
  <CENTER>  
  </ BODY>  
  </ HTML>
Прирост (+ +) и декремента (- -) Операторы

Эти операторы либо добавить 1 или вычитать 1 из операнда. В примерах, когда петли были использованы, счетчик переменной, как правило приращения или уменьшения с помощью этих двух операторов. Это в общем виде петли заявление является наиболее распространенным использованием прироста или убыли оператора: 

  за (против = 0; противодействия <20; противодействия + +) {....

Операнд, связанных с этими двумя операторами могут postaffected или preaffected. Если оператор находится в передней части операндов, значение добавляется или вычитается до следующей операции. Если оператор в конце операнда, сложения или вычитания приходит после операции. Например, следующий сценарий может быть использован, чтобы показать, как влияет на каждого операнда: 

 <html>  
 <head>  
  <title> увеличить / уменьшить оператор </ TITLE>  
  <script language="JavaScript">  
  VAR объединить = "";  
  VAR отказов = 0;  
  для (VAR борьбе = 0; противодействия <= 5; противодействия + +) ( 
        VAR гепатит отказов = + +;  
        объединить + = "гепатит стоимость =" + гепатит + "<br>";  
        )  
  document.write (объединить);  
  </ скрипт>  
  </ HEAD>  
  <body bgcolor="palevioletred">  
  <CENTER>  
  </ BODY>  
  </ HTML>

При запуске сценария, результат на экране выглядит следующим образом: 

  Гепатит стоимость = 0  
  Гепатит стоимость = 1  
  Гепатит стоимость = 2  
  Гепатит стоимость = 3  
  Гепатит стоимость = 4  
  Гепатит стоимость = 5

В первый раз через петли, переменная отказов, которые первоначально были объявлены на сумму в ноль (0), по-прежнему ноль, потому что прирост в стоимости после определения переменной гепатит. Теперь измените положение прирост оператора перед переменной, изменяя эту строку: 

  VAR гепатит = + + отказов;

Теперь этот вывод свидетельствует: 

  Гепатит стоимость = 1  
  Гепатит стоимость = 2  
  Гепатит стоимость = 3  
  Гепатит стоимость = 4  
  Гепатит стоимость = 5  
  Гепатит стоимость = 6

Как видно, позиция прирост оператор выступил одним из основных изменений в выхода. Что прирост оператора в передней части операнда, гепатит переменным приращением в первой итерации, но оно не было до второй итерации, что гепатит переменная изменилась, когда оператор был в конце операнда. Небольшие изменения в код привели к большим изменениям на выходе. Что инкремента и декремента операторов, вы должны быть особенно бдительными, не к краху программы, поскольку позиция оператора позиционируется неправильно.

Операторы в контексте использования строковых переменных и Литералы

Как вы видели при использовании плюс (+) оператора, цифры могут быть добавлены или строки и цифры могут быть вместе в одной строке. Таким образом, идея "строка оператора" очень контекстно-зависимые понятия.

Кроме того, используя плюс (+) оператора, вы можете использовать операторы сравнения (>,> =, <, <=, ==,! =) Со строками. При использовании оператора сравнения, оператор сравнивает строку операндами в алфавитном порядке основан на Unicode кодировки символов. Чем выше в алфавит символов, тем больше символов в сравнении с другим характером. Вместе с заглавных букв меньше, чем строчных букв. Таким образом, Xray меньше чрезвычайных ситуаций, насколько JavaScript обеспокоен. Ниже приводятся некоторые сценария взаимоотношения между порядком и Заглавные и маленькие струны.

stringOps.html 
 <html>  
 <head>  
  <title> Строка сравнению </ TITLE>  
  <script language="JavaScript">  
  VAR альфа = "яблоки";  
  VAR бета = "апельсины";  
  VAR Gamma = "яблоки";  
  VAR дельта = "Апельсины";  
  VAR lclc бета => "Альфа";  
  VAR lcuc альфа => гамма;  
  VAR uclc = гамма-> альфа;  
  VAR баннер = "<h3> Строка сравнению </ h3>"  
  VAR = первая бета + "больше чем" + "Альфа" + "приводит к" + lclc + "<p>";  
  VAR = втором альфа + "больше чем" + "Гамма +" приводит к "+ lcuc +" <p> ";  
  VAR третий = Delta + "больше чем" + "Альфа" + "приводит к" + uclc;  
  document.write (баннер + первого + второго + третьего);  
  </ скрипт>  
  </ HEAD>  
  <body bgcolor="mistyrose">  
  </ BODY>  
  </ HTML>

При сравнении строк с цифрами, разные результаты, чем возникает при использовании плюс (+) оператора. Вместо превращения в число строк, JavaScript попытки превратить строк в номер при сопоставлениях числовые, что связано символов в строках. Например, если вы пишете следующее, переменная альфа бы быть правдой: 

  VAR альфа = "10"> 3;

Вместе с тем, комбинация с числом следуют характеру писем не игнорировать письма и допустимое числовое сравнение с числовой операнд.

Подсказка

Всякий раз, когда вы не уверены в том, что более или менее определенное сочетание цифр, чисел и строк, или строк и строк, использование в браузере адрес окна, как испытательном стенде. Просто введите слово JavaScript:, а затем операнды и операторы.

Булевы операторы

Операторы сравнения в результате булева результаты, а три логических операторов в JavaScript можно рассматривать как булевы хорошо. Операторы комбинировать различные условия или отрицания состояния.

Логическое И (И И)

Общие требования в сценарий для двух различных условий, которые существуют на результат, чтобы быть правдой или нет. JavaScript обеспечивает логическое И (И И) оператора для определения двух или более условий. Например, массив поиска могут попытаться найти всех случаях клиенты, которые заинтересованы в покупке нового принтера, и кто живет в штате Айова, чтобы их можно было связаться для торговых принтерах шоу в Des Moines. Только если оба условия будут результаты будут верно и добавлены к списку контактов. Например, следующий сценарий сегмента ищет двух условий в массив: 

  для (VAR искать = 0; customers.length; искать + +)  
  если ((проценты [искать] == "принтер") И И (состояние [искать] == "Айова")) {....

Имейте в виду, что двойной набор скобках нужно приложить сценарий в случае, если заявление. Вы также можете использовать логические и в определении переменных. Например, в следующем скрипте, первая переменная оценивает истина, а второй оценивает ложным: 

 <html>  
 <head>  
  <title> Строка сравнению </ TITLE>  
  <script language="JavaScript">  
  VAR альфа = (15 <20) И И ( "перо"> "Меч");  
  VAR бета = ( "большой"> "высокий") И И (20 <30);  
  document.write ( "Альфа" + "<br>" + бета)  
  </ скрипт>  
  </ HEAD>  
  <body bgcolor="lightcoral">  
  </ BODY>  
  </ HTML>
Логическое ИЛИ (| |)

Логический оператор ИЛИ (| |) использует двойные трубы, как символ. Когда два или более условий, которые заявили, используя логические операторы И, лишь одно из условий, должны быть выполнены для оценки результатов, как правда. Например, переменная альфа в следующем будет оценить в действительности, даже если два условия являются ложными: 

  VAR альфа = (56 <34) | | (10> 2) | | ( "Фред"> "Алиса");

Вы также можете использовать логическое ИЛИ (или логический и) с переменным определяется булевых значения. Например, следующие строки показывают, как можно использовать логические или в скрипт: 

  VAR альфа = ( "Фасоль"> "Картофель");  
  VAR бета = 30> 40;  
  VAR гамма-альфа = | | бета-версии;

Поскольку переменная содержит альфа верно булевы значения и бета-версия содержит ложные, то переменная гамма Верно, потому что один или другой, чтобы быть правдой, не так.

Логическое НЕ (!)

JavaScript в логической НЕ (!) Служит для сводила результаты. Иногда, встроенный в функцию напротив того, что вам может понадобиться для проверки в Вашем скрипте. IsFinite () функции, используемые в качестве примера был отрицает для проведения испытаний на бесконечность. Следующий сценарий показывает иной применения логического НЕ: 

 <html>  
 <head>  
  <title> Логические НЕ </ TITLE>  
  <script language="JavaScript">  
  VAR альфа = 200 / 0;  
  VAR бета =! isFinite (альфа);  
  VAR Gamma =! (! "Альфа");  
  VAR дельта =! бета;  
  VAR B = "<br>";  
  объединить = "альфа =" + альфа + B + "бета =" + бета + B + "Gamma =" + гамма + B + "дельта =" + "Дельта";  
  document.write (объединить);  
  </ скрипт>  
  </ HEAD>  
  <body bgcolor="mintcream">  
  </ BODY>  
  </ HTML>

Скрипт генерирует следующий вывод: 

  альфа = бесконечность  
  бета = TRUE  
  Gamma = TRUE  
  дельта = ложным

Поскольку альфа стоимости порождает бесконечность, бета-версия должна генерировать верно, потому что функция! IsFinite () испытания на бесконечность. Вместе с тем, гамма переменная также генерирует правда. Отрицание переменная, содержащая верно булевой буквально порождает ложь, но так будет отрицанием какой-либо другой переменной с непостоянным булевых значения. Например, эти строки будут возвращаться неверно: 

  VAR = 5 альфа-, бета =! "Альфа";  
  document.write (бета);

Поскольку альфа не содержит булевы значения, можно предположить, что альфа-бы "нейтральной"-ни-то правдивой или ложной. Однако в скрипте, где гамма возвращает значение "истина", двойных не предшествуют ей-! (! Альфа). Это происходит потому, что! "Альфа" будет генерировать булевой ложными.

Побитовая Операторы

Если ваш сценарий требует операции побитового, вы можете использовать символы в таблице ниже, чтобы руководство вам. В целом, требует программистами несколько побитового операторов, и они включаются только здесь для полного списка доступных операторов в JavaScript и для программистов, которые могут в них нуждается.

ПРИМЕЧАНИЕ

Побитовая операции связаны бинарные числа, и вы должны понять, каким образом и когда эффективно использовать двоичное число в программе. Тем не менее, вы можете идти по жизни, как весьма эффективный программист, не говоря уже дизайнер, и никогда не иметь дело с использованием побитового операторов. Однако, если с помощью побитового операторов имеет решающее значение для JavaScript, предусмотренных программой, что вы имеете в виду, вы обнаружите, что JavaScript предоставляет широкие набор побитового операторов.

Побитовая Операторы

Символ

Операция

И

И Побитовая

|

Побитовая ИЛИ

^

Побитовая XOR

~

Побитовая НЕ

<<

Левый сдвиг

>>

Правый сдвиг

>>>

Нулевой продление в правый сдвиг

В некоторых отношениях побитового операторы, как и любой другой в том смысле, что вы используете их в те же выражения, как и любые другие операторы в JavaScript. Основное различие заключается в том, что они работают с бинарными (0S и 1S), а десятичные значения. Чтобы увидеть, что JavaScript имеет побитовое делать с операторами, рассмотреть первые семь значений в двоичное число системы: 

  0000 -0  
  0001 -1  
  0010 -2  
  0011 -3  
  0100 -4  
  0101 -5  
  0110 -6

Если цифры в одной были сдвинуты на левой одна, стоимостью 1 (0001) станет стоимостью 2 (0010), поскольку цифры в четвертой позиции с правой переносится на третьей позиции и 0 заполняет где 1 Первоначально было. Таким образом, 0001 стал 0010, или десятичная дробь 2. Использование побитового операторов в JavaScript, Вы можете заполнить те же виды деятельности. Ниже показаны в одну смену с левой, с десятичной 3 становится в десятичной 6: 

 <html>  
 <head>  
  <title> Побитовая Shift </ TITLE>  
  <script language="JavaScript">  
  VAR альфа = 3 <<1;  
  document.write ( "Альфа");  
  </ скрипт>  
  </ HEAD>  
  <body bgcolor="palevioletred">  
  </ BODY>  
  </ HTML>

Вывод на экран 6, но на JavaScript, это просто смена 0011 на 0110. Четыре битный операции показали, но JavaScript конвертирует значения для 32-разрядных чисел внутри страны с тем, что все с плавающей запятой числа преобразуются в целые числа, и округляются вниз (например, 3,9999 становится 3).

Использование typeof

Typeof оператор унарные, возвращаясь одно из следующих значений:

  • число

  • Строка

  • булево

  • объект

  • Функция

  • неопределенная

  • нуль

Для использования оператора, тип оператора (typeof), пространство и операнд, или место операнда в скобках после typeof оператора. Следующий сценарий показывает, возвращение массив (объект) и булевы значения (логическое) с использованием обоих методов применения оператора: 

 <html>  
 <head>  
  <title> typeof оператора </ TITLE>  
  <script language="JavaScript">  
  VAR много = новый Array ();  
  VAR whatTruth = 10> 4;  
  VAR kindOfData1 = typeof много;  
  VAR kindOfData2 = typeof (whatTruth);  
  VAR kindOfData = kindOfData1 + "<p>" + kindOfData2;  
  document.write (kindOfData);  
  </ скрипт>  
  </ HEAD>  
  <body bgcolor="wheat">  
  </ BODY>  
  </ HTML>

Новые, удалять и не имеющим юридической силы Операторы

Из этих последних трех операторов, обсудили, новые является наиболее широко используемым. Все объекты должны начать с конструктором предшествовать новому оператору. Как показано ранее, массив объекта начинается с новым оператором: 

  VAR семьи = новый Array ( "папа", "Мама", "Су", "Крис");

Аналогичным образом, другие конструкторы для всех объектов, использование нового.

Удалить оператор снимает объект собственности или массив элементов в сценарий. Например, следующий будет undefine элемент массива со строкой стоимость Сью: 

  VAR семьи = новый Array ( "папа", "Мама", "Су", "Крис");  
  удалить семьи [2];

Однако, несмотря на название оператора, элемент не удаляется, только стоимость. Следующий сценарий демонстрирует, что происходит: 

 <html>  
 <head>  
  <title> Удалить Элемент Значение </ TITLE>  
  <script language="JavaScript">  
  VAR семьи = новый Array ( "папа", "Мама", "Су", "Крис");  
  удалить семьи [2];  
  document.write (семья [3] + "<p>" + family.length);  
  </ скрипт>  
  </ HEAD>  
  <body bgcolor="peru">  
  </ BODY>  
  </ HTML>

Длина массива по-прежнему четыре, и последний элемент по-прежнему Крис. Однако, третий элемент массива (элемента [2]), в то время уже не Сью, по-прежнему существует. Удалить оператор просто неопределенная он.

Окончательный оператора, недействительным является унарные и работает на любом буквальном или переменной. Как правило, вы увидите этот оператор в качестве части <a> тегов в HTML скрипт, как, например, здесь: 

  <a style="text-decoration: none;" href="javascript:void(0) "onClick="scroll(500,0)">

Недействительным оператором подавляет отображение значений от оценки выражений. Все это зритель видит JavaScript: недействительным (0), в окне в нижнем левом углу, когда мышь движется на ссылку, вместо полного выражения, в том числе URL.

Статья, представленная Джорджем Freedrich

Share  
© 2005-2010 E-articles.info All Rights Reserved - Terms and conditions