Базовый синтаксис JavaScript (2)

• Ключевые слова и зарезервированные слова:

Ключевые слова:

break, else, new, var, case, наконец, return, void, catch, for, switch, while, continue, function, this, with, default, if, throw, delete, in, try, do, instanceof, typeof

Зарезервированные слова:

abstract, enum, int short, boolean, export, interface, static, byte, extends, long, super, char, final, native, synchronized, class, float, package, throws, const, goto, private, transient, отладчик, реализует , защищенный, изменчивый, двойной, импорт, общедоступный

• базовая грамматика

1. JavaScript строго чувствителен к регистру

2. Слабый тип, объявляйте переменные с помощью var (независимо от того, какой тип переменной объявлен с помощью var)

3. Добавьте точку с запятой после каждого утверждения. (Не обязательно, но рекомендуется.)

4. Строки используют одинарные кавычки 'abc'. (Также работают двойные кавычки. Рекомендуется; html→двойные кавычки, js→одинарные кавычки)

5. Примечания:

   • // однострочный комментарий

   • /* Многострочный комментарий */

   • является комментарием html, а не комментарием javascript, может использоваться для комментирования:

   • Что означает использование в тегах ?

     • Если некоторые браузеры не поддерживают JavaScript, закомментируйте содержимое тегов , чтобы они не отображались в браузере. С IE1.5 можно проверить эффект. Сейчас эту проблему в принципе можно игнорировать.

• JavaScript тип данных

1. Существует шесть типов:

   • Boolean (логическое значение), Number (число), String (строка), Undefined (не определено), Null (пустой объект), Object (тип объекта)
   • За исключением Object, который является ссылочным типом, все остальное является базовым типом данных.
   • Неопределенный тип и тип Null — это типы данных только с одним значением, которые являются неопределенными и нулевыми соответственно.

2. разница между примитивными типами и ссылочными типами

Numeric, boolean, null, undefined являются примитивными типами. Объекты, массивы и функции являются ссылочными типами. Примитивные типы имеют фиксированный размер в памяти. Значение занимает восемь байтов в памяти, а логическое значение может быть представлено одним битом. Ссылочные типы не имеют фиксированного размера.

1. Строка также является базовым типом, вы не можете добавлять динамические свойства к строке, в то время как ссылочные типы в порядке.

1. JavaScript середина null и undefined разница?

   1. undefined, что означает неизвестное состояние

      1. Переменная объявлена, но не инициализирована, значение переменной неизвестное состояние (не определено). (Доступ к несуществующему свойству или объекту window.xxx)
      2. Когда метод явно не возвращает значение, возвращаемое значение не определено.
      3. Когда оператор typeof применяется к необъявленной переменной, она выглядит как undefined(*)

   2. Null представляет объект, который еще не существует, а null — это значение со специальным значением. Переменной может быть присвоено значение null, и в это время значение переменной является «известным состоянием» (не неопределенным), то есть нулевым. (используется для инициализации переменных, очистки содержимого переменных и освобождения памяти)

   3. undefined==null //Результат верен, но смысл другой.

   4. undefined===null //false(*), сначала оцените, соответствует ли тип, а затем оцените значение.

 

• Объявление переменной:

  • При объявлении переменных вы не можете: int i=0; вы можете объявлять переменные только через var i=0;, что отличается от var в C#, а не от вывода типа в C#.
  • вар тест = "привет";
  • var test1 = «привет», возраст = 20;
  • переменная я = 100, я = «привет»;
  • var i,n,x;
  • var i=10,n=100,s='ааа',м;
  • соглашение об именах переменных :Начните с буквы, знака подчеркивания или $ и можете включать буквы, цифры, знаки подчеркивания или $. (В имени переменной есть лишний $)
  • В JavaScript вы можете использовать двойные кавычки для объявления строк или одинарные кавычки для объявления строк. В основном для удобства интеграции с html и избежания проблем с escape-символами.
  • Переменные можно использовать без объявления var, такие переменные будут считаться "глобальными переменными" (не рекомендуется)
  • JavaScript динамически типизирован, поэтому var i=0;i="abc"; является допустимым.

пример:

var i = 10;//объявляем переменную с именем i, которая указывает на целое число 10. Как только она указывает на 10, i имеет тип int.

i = "abc";//Выйти замуж за цыпленка, следовать за цыпленком, жениться на собаке, следовать за собакой!

 var n1 = '20' ;

****var n2 = '20' ;

****//Преобразование строкового типа в целочисленный тип.

**** var result = parseInt(n1) + parseInt(n2);

        alert(result);

• • Метод определения того, инициализированы ли объявленные переменные и параметры (доступны) в JavaScript:
  • Предположим, что есть переменная x:

if (typeof(x) !='undefined' && x!=null) {   alert("доступно");   }

if(x) { alert('переменная доступна!'); } else { alert('переменная недоступна!'); } //null, undefined, '', 0 считаются ложными

Когда x объявлен, но не назначен, или x равен нулю, или x равен 0, это означает, что он недоступен! //если(х), вернуть ложь

• • Рекомендуется последний метод. Но если x нельзя объявить, о нем можно судить только по typeof (иначе будет сообщено об ошибке).
• JavaScript переменная область видимости

1. По умолчанию, если вы определяете переменную непосредственно в теге скрипта, она принадлежит «глобальной области действия» (глобальной среде выполнения), то есть объекту окна.

   • Переменные в глобальной области не освобождают ресурсы, пока страница не будет закрыта или браузер не будет закрыт.
   • Переменные в нескольких тегах
   • В JS есть механизм сборки мусора, который периодически перерабатывает переменные, которые могут освобождать ресурсы. Установка переменной в значение null означает, что ее можно использовать повторно.

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

пример 1:

            function test() {

            var i = 1;

            if (1) {

                var i = 2;

                if (2) {

                    var i = 3;

                    alert(i);

                } alert(i);

            } alert(i);

} // Вывод: все 3

        test();

Пример 2:

                var scope = "global";

                function f() {

alert(scope); //результат: не определен, не глобальный

                var scope = "local";

alert(scope);//результат: локальный

                 }

f();

Многие думают, что первый вызов покажет глобальную переменную, потому что оператор var, объявляющий локальную переменную, еще не выполнен. Но из-за ограничения этого правила области действия выходные данные не являются «глобальными». Локальные переменные определены во всей функции, что означает, что глобальные переменные с одинаковыми именами скрыты во всей функции. Хотя локальная переменная определена во всей функции, она не инициализируется до тех пор, пока не будет выполнен оператор var, поэтому в приведенном выше примере функция f эквивалентна следующей функции:

function f(){

var scope;//Локальный порядок объявляется в начале функции.

alert(scope);//Здесь определена переменная, но значение по-прежнему "не определено"

scope=”local”;//Теперь мы инициализируем переменную и присваиваем ей значение.

alert(scope);//здесь переменная имеет значение

}

Примечание. Этот пример показывает, почему хорошей практикой программирования является группировка всех объявлений переменных в начале функции.

Примечание:

Присвоение значения объявленной переменной в JavaScript не вызывает ошибки, вместо этого программа неявно объявляет его в глобальной области видимости.

 

1. Строки в JavaScript также нуждаются в escape-символе ' \ ', как и в C#.

   • Если вы хотите вывести на страницу: c:\windows\microsoft\vs.txt, это предложение нужно написать так: alert('c:\\windows\\microsoft\\vs.txt'); @ cannot использоваться, @ допустимо только в C#.
   • Распространенные escape-символы: \t, \n, \', \", \\

2. Для использования if-else, for, while, do-while, switch, continue, break см. синтаксис C#. Цикл for немного отличается: for(var i=0;i

3. Примечание. Когда переключатель оценивается, он «все равны», ===

• преобразование типов

1. parseInt(arg)//Преобразовать указанную строку в целое число

2. parseFloat(arg)//Преобразовать указанную строку в число с плавающей запятой

3. Number(arg) Преобразует заданное значение (любого типа) в число (может быть целым числом или числом с плавающей запятой); преобразуется все значение, а не его часть. NaN возвращается, если строка не может быть полностью преобразована в целое число. (Не число)

   • isNaN(arg)//Определить, является ли arg не числом (NaN), и NaN и NaN не равны.

4. String(arg) преобразует заданное значение (любого типа) в строку;

5. Boolean(arg) преобразует заданное значение (любого типа) в логический тип;

6. eval(codeString)//Вычисление и выполнение js-кода строки. Подобно динамическим операторам SQL.

Alert(eval("2+3"));//Вывод результата 5

eval('alert(100);'); //выводим результат 100

Примечание: ****Результат преобразования типов

========================Boolean()===================

var b1 = Boolean(""); //false - пустая строка

var b2 = Boolean("привет"); //true - непустая строка

var b1 = Boolean(50);//true - ненулевое число

var b1 = Boolean(null);//false - null

var b1 = Boolean(0);//false - ноль

var b1 = Boolean(новый объект());//true - объект

=========================String()-================================

Эквивалентно вызову метода toString() объекта.

Специально: когда объект имеет значение null или не определен, вызов toString() сообщит об ошибке, но String() может быть успешно преобразован.

Example:

var v = null; v = String(v); // результат v равен "null"

var v; v=String(v); // результат v "не определен"

=========================Number()================================

Number (false)à0

Number(true)à1

Number(undefined)àNaN

Number(null)à0

Number("1.2")à1.2

Number("12")à12

Number("1.2.3")àNaN

Number(new object())àNaN

Number(50)à50

Советы по преобразованию между значениями:

1. преобразовать число в строку

Пример. Если в выражении конкатенации строк используется число, оно преобразуется в строку.

 var n=100;

var s=n+"були пива на валло";

Чтобы преобразовать число в строку, просто добавьте к нему пустой символ.

вар n=n+"";

Для более реалистичного преобразования чисел в строки используйте функцию String().

 var string_Value=String(number);

Другой способ преобразовать числа в строки — использовать метод toString().

string_Value=number.toString();

Метод toString() объекта Number имеет необязательный параметр, указывающий метод преобразования. Если этот параметр не указан, преобразование будет выполняться в десятичной системе счисления. Однако другие основания (числа от 2 до 36) также могут быть преобразованы. Например:

var n=17;

binary_String=n.toString(2);//Результат: "1001"

octal_String="o"+n.toString(8);//Результат: "021"

hex_String='0x'+n.toString(16);//Результат: "0x11"

1. преобразовать строку в число

Когда строка используется в числовом контексте, она также автоматически преобразуется в число.

Пример: var product="21"*"2";//Результат 42.

Используя это, мы можем преобразовать строку в число, просто вычитая 0

var number=string_Value-0;

Приведенный выше метод представляет собой трюк для преобразования строки в число, но более понятным способом является вызов конструктора Number() как функции.

Var number=Number(string_Value);

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

Чтобы обеспечить более гибкие преобразования, можно использовать parseInt() и parseFloat(). Эти функции могут начинаться со строки и возвращать любое число, игнорируя и округляя нечисловые части. parseInt() усекает только целые числа, parseFloat()

Усекать целые числа и числа с плавающей запятой.

• оператор

1. Оператор сложения (+)

Оператор «+» может добавлять числа и объединять строковые операнды. Если один операнд является строкой, другой операнд преобразуется в строку. Затем они соединяются вместе. Если операнд оператора «+» является объектом, он преобразует объект в число или строку, которые можно добавить или объединить. Это преобразование выполняется путем вызова метода объекта valueof() или toString().

1. Оператор вычитания (-)

Когда оператор штриха "-" используется для бинарных операций, он вычитает второй операнд из первой операции. Если операнды нечисловые, оператор «-» преобразует их в числа.

1. Оператор отдела (/)

Оператор «/» разделит первый операнд на его второй операнд. Если операнды нечисловые, оператор «/» преобразует их в числа. Результат деления в JavaScript — число с плавающей запятой, например 5/2, результат равен 2,5. Деление на 0 дает положительную или отрицательную бесконечность, а 0/0 дает NaN.

1. Оператор по модулю (%)

Оператор "%" вычисляет модуль первого операнда ко второму. Другими словами, это остаток, возвращаемый при делении первого операнда на второй определенное количество раз. Оператор «%» преобразует их в числа, если их операнды нечисловые. Знак результата такой же, как и знак первого операнда.

Пример: 5%2de приводит к 1.

Операции операции по модулю обычно представляют собой целые числа, но также применимы числа с плавающей запятой, например -4,3%2,1=-0,1.

1. Унарный минус (-)

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

1. Унарный плюс оператор (+)

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

1. Оператор приращения (++)

Если увеличиваемое значение не является числом, оно также преобразуется в число посредством этого процесса.

1. Оператор декремента (--) такой же, как и выше
2. Оператор равенства (==) и оператор равенства (===)

Произнесите == как «равный» и === как «точно равный», чтобы избежать путаницы.

Следующие правила используются, чтобы определить, является ли оператор === в точности равным.

1. 1. 1. 1. Если два значения имеют разные типы, они не совпадают.
         2. Если два значения имеют тип number и значения одинаковы, они эквивалентны, если только одно или оба не являются NaN (в этом случае они не эквивалентны). Значение NaN никогда не равно никакому другому значению. Включая себя, чтобы проверить, является ли значение NaN, используйте глобальную функцию isNaN();
         3. Если оба значения являются строками, и у строк точно такие же дедушки и бабушки в одной и той же позиции, то они идентичны.
         4. Если оба значения являются логическими значениями true или оба являются логическими значениями false, то они эквивалентны.
         5. Два значения идентичны, если они относятся к одному и тому же объекту, массиву или функции. Если они относятся к разным объектам (массивам или функциям), они не совсем эквивалентны, даже если два объекта имеют одни и те же свойства или два числа имеют одни и те же элементы.
         6. Если оба значения равны нулю или оба не определены, они точно такие же.

Для определения равенства операций == используются следующие правила:

• 1. 1. 1. Если два значения имеют одинаковый тип, они проверяются на равенство. Два значения равны, если они точно такие же, и неравны, если не равны.
        2. Если два типа значений различны
• Если одно значение равно null, а другое не определено, они равны.
• Если одно из них является строкой, а другое — числом, преобразованные значения используются для сравнения.
• Если значение истинно, преобразуйте его в 1. Если значение ложно, преобразуйте его в 0.
• Если одно значение является объектом, а другое — строкой, преобразуйте объект в значение моего типа-примитива и сравните его, используя метод объекта toString() или valueof() для преобразования объекта в значение типа-примитива.
• другие числовые комбинации не равны

Пример: "1"==true; //Выражение верно.

Эти два, казалось бы, совершенно разных значения на самом деле равны. Сначала логическое значение true преобразуется в число 1, затем строка «1» также преобразуется в число 1, так что теперь оба числа совпадают.

Например == и = = = Разница:

== (знак равенства), возвращает true тогда и только тогда, когда два оператора равны. != (знак неравенства)

                     var v1 = 100;

                     var v2 = "100";

               if (v1 == v2) {

Сообщить("Равно");

                 } else {

Сообщить("Не равно");

}//Выходной результат приведенного выше кода равен "равно".

=== (знак точного равенства), возвращает true, только если они равны без преобразования типов. !== (неконгруэнтный знак)

                     var v1 = 100;

                     var v2 = "100";

               if (v1 === v2) {

Сообщить("Равно");

                 } else {

Сообщить("Не равно");

} // Больше результата вывода кода "не равен".

1. Операторы сравнения: меньше () больше или равно (>=) меньше или равно (

Правила сравнения:

1. Если обе операции являются числами или обе заменены числами, выполняется числовое сравнение.
2. Если оба операнда являются строками или оба заменены строками, они сравниваются как строки.
3. Если номер оператора является строкой или преобразуется в строку. Операнд представляет собой число или преобразуется в число. затем оператор преобразует строку в число, а затем выполняет числовое сравнение. Если строка не представляет собой число, она будет преобразована в NaN, и результат сравнения будет ложным.
4. Если объект может быть преобразован в число или строку. JavaScript выполнит преобразование чисел.
5. Если ни один из операндов не может быть успешно преобразован в число или строку. , оператор сравнения всегда возвращает false
6. Операторы сравнения всегда возвращают false, если операнд имеет значение NaN или преобразуется в NaN.

Примечание. При сравнении строк учитывается регистр, все прописные буквы меньше, чем строчные. Четыре оператора сравнения возвращают false, когда операнд имеет значение NaN или преобразуется в NaN.

1. в операторе

Оператор in требует, чтобы операнд слева был строкой или мог быть преобразован в строку, а операнд справа был объектом или массивом. Он возвращает true, если левая часть оператора является именем свойства объекта с правой стороны.

Например:

var point={x:1,y:1};

var has_x_Cord="x" в точке;//правда

var has_y_Cord='y' в точке;//правда

var has_z_Cord='z' в точке;//false

1. операции с персонажами

Оператор '+' выполняет символьные операции. Он отдает приоритет строковым операндам над числовыми операндами. Если одним операндом этого оператора является строка (или объект), то другой операнд преобразуется в строку, и вместо сложения выполняется конкатенация. Оператор сравнения, с другой стороны, оба операнда являются строками, тогда он будет выполнять сравнение строк, если только один операнд является строкой, JavaScript преобразует его в число.

Пример: 1+2;//результат 3

"1"+"2";//результат 12

"1"+2;//результат 12

11

"11"

"11"

"один"

И последнее важное замечание: когда "+" используется для строк и массивов, это не обязательно ассоциативно. Результат зависит от порядка операций, если скобки не меняют этот порядок.

Пример: var s=1+2+"слепые мыши";//результат: "3слепые мыши"

var t=”слепые мыши”+1+2;//результат: слепые мыши3

1. Логические операторы

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

1. Оператор создания объекта (новый)

Пример: o=новый объект();

1. удалить оператор

Оператор удаления — это унарный оператор, который удалит свойство, элемент массива или переменную объекта, указанного операндом. Возвращает true, если удаление прошло успешно, и false, если удаление невозможно. Не все свойства и переменные могут быть удалены, некоторые внутренние базовые свойства и свойства на стороне клиента не могут быть удалены, а пользовательские переменные, объявленные с помощью оператора var, не могут быть удалены. Он вернет true, если оператор, используемый для удаления, является несуществующим свойством.

Пример: var o={x:1,y:2};

     delete o.x;//return true

     typeof o.x;//undefined

     delete o.x;//return true

     delete o;//return false

        delete 1;//return true

              x=1;

       delete x;//return true

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

удаление может влиять только на значения свойств, а не на объекты, на которые ссылаются эти свойства.

Пример: var my=new Object();

       my.hire=new Date();

    my.fire=my.hire;

       delete my.hire;

    document.write(my.fire);

• утверждение

1. Оператор switch: Ключевое слово break используется в конце каждого оператора case.

Примечание. За ключевым словом case следует числовой и символьный литерал, что является наиболее распространенным методом операторов switch в практических приложениях, но стандарт eCMScript v3 позволяет после операторов case следовать произвольным выражениям.

Оператор switch сначала оценивает выражение ключевого слова switch, а затем оценивает выражения после case в том порядке, в котором они появляются, до тех пор, пока выражение case не будет соответствовать значению выражения switch. Поскольку совпадающие выражения case упорядочиваются с помощью оператора равенства ===, а не оператора равенства ==, выражения должны совпадать без преобразования типов.

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

1. для/в выписке

Ключевое слово for используется в JavaScript двумя способами. Мы только что видели, как использовать его в циклах for, и его также можно использовать в операторах for/in. Этот оператор представляет собой немного специальный оператор цикла, его синтаксис выглядит следующим образом:

 for(variable in object)

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

Примечание. Переменная в цикле for/in может быть любым выражением, если ее значение относится к левой части выражения присваивания. Значение выражения оценивается каждый раз через цикл, что означает, что значение каждый раз разное, например:

var o={x:1,y:2,z:3};

var a=new Array();

var i=0;

for(a[i++] in o)