JavaScript Core Compet Types, значения и переменные

Работа компьютерной программы требует рабочих значений, таких как номер 3.14 или текст «Hello World». В языках программирования тип значения, который может быть представлен и эксплуатироваться, называется типом данных. Самая основная особенность языков программирования - размещать несколько типов данных. Когда программа должна сохранить значение для будущего использования, она назначается («сохранить» значение для) переменной. Переменная является символическим именем значения, и ссылка на значение может быть получена по имени. Рабочий механизм переменных является основной особенностью языков программирования. В этой главе будет ссылаться на предыдущий раздел, чтобы помочь понять содержание этой главы, и будет более подробно объяснено позже.

Данные JavaScript разделены на две категории: примитивный тип и тип объекта

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

JavaScript является объектом, кроме чисел, строк, логических значений, нулевых и неопределенных. Объект - это коллекция свойств. Каждый атрибут состоит из «пары имен/значения» (значение может быть примитивным значением, таким как число, строка или объект). Один из наиболее специальных объектов (глобальный объект будет представлен в мисс Пятой, а шестой раздел будет описан более подробно)

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

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

Если функция инициализирует (используя новый оператор) новый объект, мы называем его конструктором. Каждый конструктор определяет коллекцию класса A-объекта, состоящая из объектов инициализации конструктора. Классы можно рассматривать как подтипы типов объектов. В дополнение к классам массива и классам функций JavaScript также определяет три других используемых класса. Дата определяет объект, представляющий дату. REGEXP определяет объект регулярных выражений. Класс ошибок определяет строку, которая представляет ошибку времени выполнения и объект ошибки синтаксиса в программе JavaScript. Вы можете определить требуемый класс, определив свой собственный конструктор.

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

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

a.sort (); // Сортировать (а) объектно-ориентированная версия

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

Типы JavaScript можно разделить на примитивные типы и типы объектов и могут быть разделены на типы, которые могут иметь методы и типы, которые не могут иметь методов. Его также можно разделить на изменчивые и неизменные типы. Значения изменяемых типов могут быть изменены, а объекты и массивы принадлежат изменяемым типам: программы JavaScript могут изменить значение значения атрибута объекта и значение элементов массива.

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

JavaScript может свободно выполнять преобразование типа данных. Например, если число используется, когда программа ожидает использовать строку, JavaScript автоматически преобразует номер в строку. Если вы рассчитываете использовать не буловое значение, где используется логическое значение, JavaScript также будет преобразован соответственно. В JavaScript правила «равенства суждения» используются для «равенства равенства» (равенство)

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

1. Числа

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

Я тип целого типа прямое количество

Десятичное целое число представлено последовательности массива в JavaScript

В дополнение к десятичному целочисленному прямому количеству, JavaScript также признает значения шестнадцати механизма (16) в качестве кардинальности. Так называемая шестнадцатеричная система представляет собой прямое количество, префиксированное «0x» или «0x», за которой следует строка шестнадцатеричных чисел. Гексадецимальное значение состоит из букв между 0-9 и (a) -f (f). Буквы AF выражены в числах 10-15 ниже. Вот примеры прямых количеств шестнадцатеричных целых чисел.

Кода -копия выглядит следующим образом:

0xff // 15*16+15 = 255

0xcafe911

Хотя ECMASCRICT не поддерживает восьмиурочные прямые величины, некоторые реализации JavaScript могут разрешить представление целых чисел в восьмиуровне (база 8). Октальное прямое количество начинается с числа 0, за которой следует последовательность чисел от 0 до 7.

Кода -копия выглядит следующим образом:

0377 // 3*64 +7*8 +7 = 255 (Десятичный)

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

II Прямое количество с плавающей запятой

Прямые величины с плавающей запятой могут содержать десятичные точки, и они используют традиционный метод написания реального числа. Реальное число состоит из целочисленной части, десятичной точки и десятичной части.

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

Может быть выражен в более кратком синтаксисе

Кода -копия выглядит следующим образом:

[цифры] [. цифры] [(e | e) [(+|-)] цифры]

3.14

2345.455

.33333333333333333333333333333333

6.02e23 //6.02*10 к 23 -й власти

1.255454E-23 //1.2554544*10 к 23-й власти

Арифметическая операция в III.javascript

В программах JavaScript используются арифметические операторы, предоставленные языковой провинцией для выполнения численных операций. Эти операторы содержат + - * / и оставшийся (разделенный остаток) Оператор %

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

Кода -копия выглядит следующим образом:

Math.pow (2, 53) // => 9007199254740992 Document.Write (Math.Pow (2,53))

Math.round (.6) //=>1.0 раунд

Math.ceil (.6) //=>1.0

Math.floor (.6) //=>0.0 вниз

Math.abs (-5) // => 5 Найти абсолютное значение

Math.max (x, y, z) // возвращает максимальное значение

Math.min (x, y, z) // возвращает минимальное значение

Math.random () // генерировать псевдо-рэндовое число больше 0 и меньше 1

Math.pi // pi

Math.e // e: База естественного логарифма

Math.sqrt (3) // 3 квадратный корень

Math.pow (3, 1/3) // 3 Cube Root

Math.sin (0) // Тригонометрические функции, а также math.cos, math.atan и т. Д.

Math.log (10) //=>2.302585092994046 Натуральный логарифм с базой 10

Math.log (512) /math.ln2 // log 512 с базой 2

Math.log (100) /math.ln10 // log 100 с базой 10

Math.exp (3) // Электи

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

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

JavaScript предопределенные глобальные переменные Infinaty и NAN для выражения ненуковых значений. В ECMASCIPT3 эти два значения могут быть прочитаны и написаны. Ecmascript5 исправил эту проблему, определяя их как только для чтения. Значение атрибута, определенное объектом Number в ECMASCIPT3, также только для чтения, вот несколько примеров:

Кода -копия выглядит следующим образом:

Infinity // Инициализировать переменную для чтения/записи в бесконечность

Number.positive_infinity // Только же значение, только чтение

1/0 // Это то же самое значение

Number.max_value + 1 // Результат расчета все еще бесконечность

Number.negative_infinity // обозначает отрицательную бесконечность

-Бесконечность

-1/0

-Number.max_value -1

NAN // Инициализировать переменную для читаемой/записи для NAN

Number.nan // одинаковое значение, но только прочитайте

0/0 // Результат расчета все еще НАН

Number.min_value/2 // Произошла недостаток. Рассчищенный результат - 0

-Number.min_value/2 // Отрицательный ноль

-1/Infinity // Отрицательное ноль

-0 // Отрицательный ноль

В JavaScript есть немного особенного в отношении явных значений, которые не равны людям и ценностям, включая самих себя. Другими словами, невозможно судить, является ли x nan от x == nan. Вместо этого x должен использоваться! = x, чтобы судить, что, если и только когда x является NAN, результат выражения верно. Функция isnan () функция аналогична этой. Если параметром является NAN или ненужное значение (например, строка и объект), он возвращает TRUE. В JavaScript существует аналогичная функция, которая isfinite (), которая возвращает true, когда параметры не являются NAN, Infinty или -infinity.

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

Кода -копия выглядит следующим образом:

var Zero = 0;

var negz = -0;

Zero === negz // => true положительные и отрицательные нулевые значения равны

1/Zero === 1/negz // ложная положительная бесконечность и отрицательная бесконечность разные

IIII.BINARY Номер плавающей запятой и ошибка округления

Существует бесчисленное множество реальных чисел, но JavaScript может представлять собой конечные числа только через форму чисел с плавающей запятой (если быть точным, есть 18 437 736 874 454 810 627), то есть, когда реальные числа используются в JavaScript, это часто является просто приблизительным представлением реальной ценности.

JavaScript принимает обозначения IEEE-754 номера с плавающей запятой (используется почти всеми современными языками программирования). Это двоичное представление, которое может точно представлять фракции, такие как 1/2 1/8 и 1/1024. К сожалению, фракции, которые мы часто используем, особенно в финансовых расчетах, все основаны на десятичных фракциях 1/10, 1/100 и т. Д. Бинарная нотация не может представлять простое число, например, 0,1.

Числа в JavaScript имеют достаточную точность. И может быть близко к 0,1. Но на самом деле, неспособность точно выразить цифры вызывает некоторые проблемы.

Кода -копия выглядит следующим образом:

var x = .3 - .2;

var y = .2 - .1;

предупреждение (x == y) // => false Два значения не равны

x == .1 // => false .3 -.2 не равняется .1

y == .1 // => true .2-.1 равна 1

Из-за ошибки округления приблизительная разница между 0,3 и 0,2 фактически не равняется приблизительной разнице между 0,2 и 0,1 (в реальных средах моделирования, 0,3-0,2 = 0,099 999 999 999 999 999 999 98). Эта проблема не только присутствует в JavaScript, но и очень важно понимать это: эта проблема возникнет на любом языке программирования, который использует бинарные номера с плавающей запятой. Также важно отметить, что значения x и y в приведенном выше коде очень близки друг к другу и окончательные правильные значения. Этот результат расчета может быть компетентным для большинства задач расчета. Эта проблема возникает только при сравнении, равны ли два значения.

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

IIIII.Date и время

Ядро языка JavaScript включает конструктор Date (), который первоначально создал объекты даты и времени. Методы этих объектов даты предоставляют простой API для расчета даты. Объекты даты не могут быть основными типами данных, такими как номера.

Кода -копия выглядит следующим образом:

var Zhen = новая дата (2011, 0, 1); // 1 января 2011 г.

var позже = новая дата (2011, 0, 1, 17, 10, 30); // тот же день

var теперь = new Date (); // текущая дата и время

var elpsed = сейчас - Zhen; // вычитание даты. Рассчитайте количество миллисекундов временного интервала

позже. // => 2011

Позже.getmonth (); // => 0 месяцев, подсчитано от 0

позже.getDate (); // => 1 Количество дней, подсчитано из 1

Позже.getday (); // => 5 Получите день недели. 0 представляет воскресенье, 5 представляет воскресенье

Позже.gethours () // => локальное время

Позже.getatchours () // Используйте UTC, чтобы представить время часа на основе часового пояса.

2. Текст

Строка представляет собой неизменную и упорядоченную последовательность 16-битных значений, каждый символ обычно происходит из набора символов Unicode. JavaScript представляет текст через типы строк. Длина строки-это число 16-битных значений, которые она содержит. Индекс строки JavaScript (и ее массив) начинается с 0. Длина пустой строки равен 0, и нет «типа символа», представляющего один символ в JavaScript. Чтобы представить 16-битное значение, просто назначьте его на строковую переменную. Длина этой строки составляет 1.

Набор символов, внутренний код и строка JavaScript

JavaScript использует набор символов Unicode Unicode UNICODE UTF-16, а строка JavaScript-это последовательность, состоящая из набора неупорядоченных 16-битных значений. Наиболее часто используемые символы Unicode представлены 16-битными внутренними кодами и представляют собой один символ в строке. Символы Unicode, которые не могут быть представлены как 16-битные правила кодирования UTF-16-используя два 16-битных значения для формирования последовательности (также известных как «пары прокси»). Это означает, что строка JavaScript длины 2 (два 16-битных значения) может представлять собой символ Unicode.

Кода -копия выглядит следующим образом:

var p = "π"; // π представлен 16-битным внутренним кодом 0x03c0

var e = "e"; // E представлен 17-битным внутренним кодом 0x1d452

P.Length // => 1 P содержит 16-битное значение

E.Length // => 2 E, кодируемый UTF-16 содержит два значения: "/ud835/udc52"

Все методы работы строки, определенные ACT JavaScript на 16-битных значениях, а не символах, и не обрабатывают прокси-элемент отдельно. Точно так же JavaScript не будет стандартизировать обработку строк. Нет гарантии, что строки являются законным форматом UTF-16

Я строю прямое количество

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

Кода -копия выглядит следующим образом:

"// Пустая строка, 0 символов

'тестирование'

"3.14"

'name = "myform"

"Разве ты не предпочел бы книгу О'Рейли?"

В Ecmascript3 прямое количество строки должна быть записана в одной строке, в то время как в Ecmascript5 прямое количество строки может быть разделена на несколько строк, и каждая строка должна заканчиваться с обратной задачей (/). Ни обратная сбоя, ни конечный символ линии не являются содержимым прямого количества строки. Если вы хотите быть вместе, вы можете использовать /n, чтобы избежать персонажей.

Следует отметить, что при использовании отдельных цитат для разграничения строк вы должны быть очень осторожны с аббревиатурами и всеми форматами на английском языке. Английские апострофы и отдельные кавычки - один и тот же символ, поэтому для сбега необходимо использовать обратную черту (/).

II Escape персонажей

В струнах JavaScript Backslashes (/) имеют особое назначение. Добавление персонажа в обратные склады больше не будет представлять их буквальное значение. Например, /n - экологичный символ, который представляет собой новую линию.

Кода -копия выглядит следующим образом:

/o // NUL символы

/B // Персонаж обратного пространства

/T // Символ горизонтальной вкладки

/n // Символ Newline Line

/v // Вертикальный символ вкладки

/f // обновление страницы

/r // Возвращение кареты символ

/"// Двойные цитаты

// BackSlash

/xxx latin-1 символ, указанный двухбитным шестнадцатеричным

/xxxxxx символ Unicode, указанный четырехбитовым шестнадцатеричным XXXXX

Использование III строки

Одной из встроенных функций JavaScript является string concatenation. Используйте оператор + для строк, чтобы представить конкатенацию строки. Например

Кода -копия выглядит следующим образом:

var msg = "hello" + "мир"; // генерировать строку Hello World

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

S.Length

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

Кода -копия выглядит следующим образом:

var s = "Привет, мир";

S.Charat (0); // "H" Первый персонаж

S.Charat (S.Length - 1) // "D" Последний персонаж

S.Substring (1, 4) // "ell" 2-4 символа

S.Slice (1, 4) // ELL то же самое, что и выше

S.Slice (-3) // Появляются последние 3 символа

S.Indexof (L ") // 2 символ L Первое положение вступления

S.LastIndExof ("L") // 10 в последний раз, когда появляется символ L

s.indexof ("l", 3) // после позиции 3, первая позиция, где появляется символ L

S.Split (",") // => ["hello", "World"] разделен на подстроки

S.Replace ("h", "h") // => "hllo, мир" Полный текст замена символов

s.touppercase () // => "Привет, мир"

В JavaScript строки фиксируются и неизменны. Такие методы, как reply () и touppercase (), возвращают новые строки, и сами исходные символы не изменились.

В Ecmascript символы можно рассматривать как массивы только для чтения. В дополнение к использованию метода Charat (), квадратные кронштейны также могут использоваться для доступа к отдельным символам в строке. (16-битное значение)

Кода -копия выглядит следующим образом:

S = "Привет, мир"

s [0] // => "h"

S [S.Length-1] // => "D"

Foxfire поддерживает индексацию струн для этого метода давным -давно, и большинство современных браузеров (кроме IE) пошли по стопам Mozailla и завершили эту функцию до того, как был сформирован Ecmascript.

IIII -шаблон сопоставление

JavaScript определяет конструктор regexp (), который используется для создания объектов, которые представляют сопоставление текстовых шаблонов. Эти паттерны называются «регулярными выражениями», синтаксисом регулярного выражения в JavaScript Perl. Как строки, так и объекты REGEXP определяют функции, которые используют регулярные выражения, чтобы соответствовать шаблонам, находить и заменить.

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

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

Кода -копия выглядит следующим образом:

/^Html/// match Strings, начиная с HTML

/[1-9] [0-9]*/// Сопоставьте ненулевой номер, за которым следует любое число

// bjavascript/b/i/// Сопоставьте слово Javascript и игнорировать верхний и нижний чехол

Объект Regexp определяет много полезных методов, а строки также имеют методы, которые могут принимать параметры Regexp. Например:

Кода -копия выглядит следующим образом:

var text = "тестирование: 1,2,3"; // текстовый пример

var pattern = // d+/g // Сопоставление всех экземпляров, содержащих одно или несколько чисел

pattern.test (text) // => true: совпадение успешно

text.search (pattern) // => 9: позиция, где была успешная первая матча

text.match (pattern) // => ["1", "2", "3"] Все совпадения сочетаются с массивом

Text.Repeat (шаблон, "#"); // => "Тестирование:#,#,#"

text.split (// d+/); // => ["", "1", "2", "3"]: Используйте ненуковые символы, чтобы перехватить строки

3. логическое значение

Логические значения относятся к истинному или ложному, включено или выключены. Этот тип имеет только два значения, и слово True или False зарезервировано.

Результаты операторов сравнения в JavaScript обычно являются логическими значениями. Например

a == 4

Этот код используется для выявления того, равно ли значение a переменной равным 4. Если он равно, значение является истинным, если значение не равно, ложно

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

Кода -копия выглядит следующим образом:

if (a == 4)

b = b + 1;

еще

a = a + 1;

Любое значение JavaScript может быть преобразовано в логические значения, а следующие значения преобразуются в False

Кода -копия выглядит следующим образом:

неопределенный

нулевой

0

-0

Нэн

"// Пустая строка

Все остальные значения, включая все объекты (массивы), будут преобразованы в TRUE, FALSE, а вышеуказанные 6 значений, которые могут быть преобразованы в FALSE, иногда называют «ложными значениями». JavaScript ожидает, что при использовании логического значения ложное значение будет рассматриваться как ложное, а истинное значение будет рассматриваться как истинное.

Давайте посмотрим на пример. Добавление переменной o является объектом или нулем, вы можете использовать оператор IF, чтобы определить, является ли O не нулевым значением.

if (o! == null) ...

Неравный оператор "! ==" сравнивает o и null и дает результат истинный или ложный. Сначала вы можете проигнорировать утверждение сравнения здесь. NULL является ложным значением, а объект является истинным значением.

if (o) ...

Для первого случая код после того, если будет выполняться только тогда, когда O не является нулевым, а ограничения второго случая не так строги. Это, если выполняется только в том случае, если o не является ложным или каким -либо ложным значением (например, нулевым или не подготовленным).

Boolean содержит метод ToString (), поэтому вы можете использовать этот метод для преобразования строки в «true» или «false», но он не содержит других полезных методов, и в дополнение к этому неважному API есть три важных логических оператора.

&& оператор, || оператор и унаральный оператор "!" Выполните логическую не (не) операцию. Если значение True возвращает FALSE, значение FALSE возвращает true, например,

Кода -копия выглядит следующим образом:

if ((x == 0 && y == 0) ||! (z == 0)) {

// x и y как нулевые, так и z являются ненулевыми

}

4.null и не определен

NULL - это ключевое слово на языке JavaScript. Он представляет собой специальное значение «нулевое значение». Для NULL он выполняет работу TypeOF () и возвращает объект. То есть NULL можно рассматривать как специальное значение объекта, что означает «некомъективный». Но на самом деле, NULL обычно считается единственным членом его свободного типа. Это может представлять, что числа, строки и объекты «бесценны». Большинство языков программирования содержат NULL, как JavaScript, и вы можете быть знакомы с нулевым или нулевым.

JavaScript также имеет второе значение, указывающее на вакансию значения. Используется для представления более глубоких «нулевых значений». Это значение переменной. Указывает, что переменная не была инициализирована. Если вы хотите запросить значение атрибута объекта или элемента массива, он возвращает неопределенную, это означает, что атрибут или элемент не существует. Неопределенным является предопределенная глобальная переменная (она отличается от нулевой, оно не является ключевым словом), а ее значение не определен. Если вы используете TypeFOF для проверки неопределенного типа, возвращается «неопределенный», указывая, что значение является единственным членом типа.

Хотя нулевые и неопределенные разные, они оба представляют «вакансии значений», и они часто взаимозаменяемы. Оператор, который судит равенство "==", считает, что эти два равны (используйте оператор строгого равенства "===", чтобы различить их). Если ожидается, что значение будет иметь логический тип, их значения все ложные. Похоже на ложь. Как нулевые, так и неопределенные не содержат никаких свойств и методов. На самом деле, используя "". и «[]», чтобы получить доступ к членам или методам этих двух значений, приведет к ошибке типа.

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

5. Глобальные объекты

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

Глобальный объект имеет важное использование в JavaScript. Свойства глобального объекта - это символы, определенные во всем мире. Программы JavaScript можно использовать напрямую. Когда начинается интерпретатор JavaScript, он создает новый глобальный объект и дает ему набор определенных начальных свойств.

Глобальные свойства, такие как неопределенная Infinty и NAN

Глобальные функции, такие как isnan (), parseint () и eval ()

Конструкторы, такие как date (), regexp (), string (), object () и array ()

Глобальные объекты, такие как математика и JSON

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

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

var global = this; // Определите глобальную переменную, которая ссылается на глобальный объект.

В клиентском Javascript объект Window действует как глобальный объект. Этот глобальный окно -объект имеет саму ссылку на окно. Это может заменить это для обозначения глобального объекта. Windows определяет глобальные атрибуты Core. Тем не менее, некоторые другие глобальные атрибуты определены для веб -браузеров и интерактивного JavaScript.

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

6. Упаковочный объект

Объект JavaScript - это составное значение: это набор атрибутов или именованных значений. Значение атрибута ссылается через "". Когда значение атрибута является функцией, это метод и использует OM () для передачи методов в объекте o.

Мы видим, что строки также имеют свойства и методы.

Кода -копия выглядит следующим образом:

var s = "Привет, мир";

var word = s.substring (s.indexof ("")+1, s.length); // Использование атрибутов строки.

Document.Write (Word) // "Ello World"

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

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

Посмотрите на следующий код и подумайте об их процессе выполнения

Кода -копия выглядит следующим образом:

var s = "test";

s.len = 4; // Установить для него свойство

var t = s.len // Найти это свойство

При запуске этого кода значение T не определен. Вторая строка кода создает временный объект строки и дает LEN значение 4. Затем объект уничтожается. Третья строка использует исходную (не измененную) строку для создания нового объекта строки и пытается прочитать атрибуты Лена.

Это свойство не существует естественным образом, указывая на то, что результат не определен. Этот код показывает, что при чтении значений свойств (или методов) строк, массивов и логических значений он ведет себя как объект, но если вы пытаетесь присвоить значение его свойству. Эта операция будет проигнорирована; Модификация случается только для временных объектов. Этот временный объект не был сохранен.

Следует отметить, что создание объектов обертки может отображаться через конструкторы string (), number () и boolean ():

Кода -копия выглядит следующим образом:

var s = "test",

n = 1,

b = true;

var s = new String (ы);

var n = новое число (n);

var b = new Boolean (b);

JavaScript преобразует обертку в исходное значение при необходимости, поэтому объект SNB в предыдущем коде часто - но не всегда - представляет то же значение, что и SNB, "==", равное оператору, рассматривает исходное значение и его объект обертки как равное.

Но полный оператор «===» рассматривает их как неравенство, и разница между исходным значением и объектом, которое он обертывает, можно увидеть через оператор типа.

7. Необываемые исходные значения и ссылки на изменения объектов.

Первоначальное значение JavaScript (неопределенные нулевые логические числа и строки) принципиально отличается от объектов (включая массивы и функции). Исходное значение неизменно; Ни один метод не может (или мутировать) примитивное значение. Это, очевидно, верно для чисел и логических, изменение значения числа сама по себе не имеет смысла, но это не так очевидно для строк, потому что строки кажутся множеством символов. Мы ожидаем, что символы в строке могут быть изменены с помощью указанного индекса. На самом деле JavaScript запрещает это делать. Все методы в строке, по -видимому, возвращают измененную строку, которая на самом деле является новой строкой.

Кода -копия выглядит следующим образом:

var s = "Привет, мир";

s.touppercase (); // возвращать "привет мир" и не меняет ценность s

S // => «Hello World» оригинальная строка не изменилась

原始值的比较是值的比较，只有在他们的值相当时它们在才相等。这对数字、布尔值、null和undefined来说听起来有点难，并没有其他办法来比较他们。同样，对于字符串来说则不那么明显；如果比较两个单独的字符串，当且仅当他们的长度相等且每个索引的字符都相等时，javascript的才认为相等。

Кода -копия выглядит следующим образом:

var o = {x:1} //定义一个对象

ox = 2 //通过修改对象的属性来改变对象

oy = 3 //再次更改这个对象，给它增加一个新属性

var a =[1,2,3] //数组也是可以修改的

a[0]=0; //更改数组中的一个元素

a[3]=4; 给数组增加一个新元素

对象的比较并非值的比较：即使两个对象包含同样的属性及相同的值，他们也是不相等的，各个索引元素完全相等的两个数组也不相等

Кода -копия выглядит следующим образом:

var o ={x:1}, p={x:1}//两个具有相同属性的两个对象

o === p ;//=>false 两个单独的对象永不相等( o == p ; =>false)

var a =[],b=[]; //两个单独的空数组

a === b ; //=>false两个单独的数组永不相等

我们通常将对象称为引用类型(reference type),以此来和javascript的基本类型区分开来。依照术语的叫法，对象都是引用(reference),对象的比较均是引用的比较；当且当它们应用同一个基对象时，它们才相等。

Кода -копия выглядит следующим образом:

var a = []; //定义一个引用空数组的变量a

var b = a; //变量b引用同一个数组

b[0] = 1;

a[0] //=>1 变量a也会修改

a === b //=>true a和b引用同一个数组，因此他们相等。

就像你刚才看到的如上代码，将对象（或数组）赋值给一个变量，仅仅是赋值的引用值：对象本身并没有复制一次。

如果你想得到一个对象或数组的副本，则必须显式复制对象的每个属性或数组的每个元素。下面的这个例子则是通过循环来完成对数组的复制。

Кода -копия выглядит следующим образом:

var a = ['a', 'b', 'c']; //待复制的数组

var b = []; //复制到目标的空数组

for (var i = 0; i < a.length; i++) { //遍历a[]中的每个元素

b[i] = a[i]; //将元素复制到b中。

}

同样的，如果我们想比较两个单独或者数组，则必须比较他们的属性或元素。下面这段代码定义了一个比较练个数组的函数。

Кода -копия выглядит следующим образом:

function equalArrays(a, b) {

if (a.length != b.length) return false; //两个长度不相同的数组不相等

for (var i = 0; i < a.length; i++) //循环遍历所有元素

if (a[i] !== b[i]) return false; //如果有任意元素不等，则数组不相等

вернуть истину; // Otherwise they are equal

}

8.类型转化

javascript中的取值型非常灵活，我们已经从布尔值看到了这一点：当javascript期望使用一个布尔值时候，你可以提供任意类型值。javascript将根据需要自行转换类型。一些值（真值）为true，其它值（假值）转化为false.这在其它类型中同样适用。如果javascript期望使用一个字符串，它把给定的值转换为字符串。如果javascript期望使用一个数组，它把给定的值转换为数字（如果转化结果无意义的话将返回NaN）,一些例子如下：

Кода -копия выглядит следующим образом:

10 + "object" //=> "10object";

"7" * "4" // =>28 两个字符串均转化为数字

var n = 1 - "x" // =>NaN字符串x无法转换为数字

n + " objects" // =>"NaN objects":NaN转换为字符串"NaN"

下表说明了在javascript中如何进行类型转化。粗体突出了那些让你倍感意外的类型转化。空单元格表示不必要也没有执行的转换。

上表提到的原始值到原始值的转换行对简单，我们已经在第本文第三小节讨论过转换为布尔值的情况了。所有原始值转换为字符串的情形也已经明确定义。转换为数字的情形比较微妙。那些以数字表示的字符串可以直接转化为数字，也允许在开始和结尾处带有空格。但在开始和结尾处的任意非空字符都不会被当成数字量的一部分，进而造成字符串为数字的结果为NaN。有一些数字转换看起来让人奇怪：true转换为1，false、空字符串""转换为0.

原始值到对象的转换也非常简单，原始值通过调用String()，Number()或Boolean()构造函数，转化为它们各自的包装对象。见本文第6节。

null和undefined属于例外，当将它们用在期望是一个对象的地方都会造成一个类型错误(TypeError)异常。而不会执行正常的转换。

对象到原始值的转换多少有些复杂，本小节第三小节有专门描述。

я. Conversion and Equality

由于javascript可以做灵活的类型转换，因此其“==”相等运算符也随相等的含义灵活多变。例如：如下这些比较结果均是true；

null == undefined //这两值被认为相等

"0" == 0 //在比较之前，字符串转换成数字。

0 = false //在这之前布尔值转换成数字。

"0" ==false //在比较之前字符串和布尔值都转换成数字

在第四章9节第一小节相信讲解了“==”等于运算符在判断两个值是否相等时做了那些类型转换，并同样介绍了“===”恒等运算符在判断相等时并未做任何的类型转换。

需要特别注意的是：一个值转换为另一个值并不意味着两个值相等。比如在期望使用布尔值的地方使用了undefined，将会转换为false，但这不表明undefined==false。javascript运算符和语句期望使用多样化的数据类型，并可以互相转换。if语句将undefined转化为false,但“==”运算符从不试图将其转化为布尔值。

ii.显式类型转化

尽管javascript可以做做很多类型转换，但有时仍需要做显式转换，或者为了使代码变得清晰易读而做显式转换。

做显式转换最重简单的方法就是使用Boolean()、Number()、String()或Object函数。我们在本文第6节已经介绍过了. 当不通过new运算符调运这些函数时，他们会作为类型转换函数并按照上边表格所描述的规则做类型转换。

Кода -копия выглядит следующим образом:

Number("3") //=>3

String(false) //=>"false"或使用false.toString()

Boolean([]) //=>true

Object(3) // =>new Number(3)

需要注意的是，除了null或undefined之外的任何值都具有toString()方法，在这个方法的执行结果通常和String()方法返回的结果一致。同样需要注意的话，如果试图把null或undefined转化为对象。则会抛出一个类型错误typeerro。Object()函数在这种情况下不会抛出异常：它仅简单返回一个新创建的空对象。

javascript中的某些运算符会做隐式的类型转换，有时用于类型转换。如果“+”运算符的一个操作数是字符串，它将会把令一个操作数转换为字符串。一元“+”运算符将其操作数转换为数字。同样，一元“！”运算符将其操作数转换为布尔值取反，在代码中常会看到这种类型转换的惯用法。

Кода -копия выглядит следующим образом:

x + "" // 等于字符串String(x)

+x //等价于Number(x),也可以写成x-0

!!x //等价于Boolean(x)

在计算机中数字的解析和格式化代码是非常普通的工作。javascript中提供了专门的函数和方法用来更加精确的数字到字符串（number-to-string）和字符串到数字(string-to-number)的抓换。

Nmuber类定义的toString()方法可以接收表示基数（二进制，八进制，十六进制等）的可选参数，如果不指定该参数，转化规则将是十进制。同样也可以将数字转换为其它进制数。（范围在2-36之间）

Кода -копия выглядит следующим образом:

var n = 17;

b_string = n.toString(2); //转化为10001

o_string = "0" + n.toString(8); //转化为八进制021

hex_string = "0x" + n.toString(16); //转化为16进制0x11

javascript为控制输出中小数点位置和有效数字位数，或者决定是否需要指定指数计数法。Number类为这种数字到字符串定义了三个方法。

toFixed()根据小数点后指定位数，将数字转换为字符串，它从不使用指数计数法。toExponential()使用指数计数法，将数字转换为指数形式的字符串，其中小数点前只有一位，小数点后的位置则由参数指定（也就是说有效数字位数要比指定的位数多一位）。toPrecision()根据指定的有效数字位数，将数字转换为字符串。如果有效数字的位数小于数字整数部分的位数，则转换成指数形式。我们注意到，三个方法都会适当的进行四舍五入或填充0,

Кода -копия выглядит следующим образом:

var n = 123456.789;

n.toFixed(0); //"123457"

n.toFixed(2); //"123456.79"

n.toFixed(5); //"123456.78900"

n.toExponential(1); //"1.2e+5"

n.toExponential(3); //"1.235e+5"

n.toPrecision(4); // "1.235e+5"

n.toPrecision(7); //"123456.8"

n.toPrecision(10); //"123456.7890"

如果通过Number()转换函数传入一个字符串，它会试图将其转化为一个整数或浮点数直接量，这个方法只能基于十进制进行转换，并且不能出现非法的尾随字符。parseInt()和parseFloat()函数（它们是全局函数，不属于人和类的方法），更加灵活。parseInt()只解析整数。而parseFloat()则可以解析整数和浮点数。如果字符串前边是0x或0X,parseInt()将其解析为16进制数。两个方法都会跳过任意量的前导空格，尽可能解析更多数值字符。并忽略后边的内容。如果第一个是非法的数字直接量，则返回NaN

Кода -копия выглядит следующим образом:

parseInt("3many nice") //=>3;

parseFloat("3.14meters") //=>3.14

parseInt("-12.34") //=>-12

parseInt("0xff") //=>255

parseInt("-0XFF") //=>-255

parseFloat(".1") // =>0.1

parseInt("0.1") //=> 0

parseInt(".1") //=>NaN 不能以.开始

parseInt("$112") //=>NaN 不能以$开头

parseInt()可以接收第二个可选参数。这个参数指定数字转换的基数。合法的取值范围是2-36

Кода -копия выглядит следующим образом:

parseInt("11", 2) //=>3(1*2+1)

parseInt("ff", 16) //=> 255(15*16 +15)

parseInt("zz", 36) //=>1295(35*36+35)

parseInt("077", 8) // 63(7*8 +7)

parseInt("077", 10) //77(7*10+7)

iii. The object is converted to the original value.

对象到布尔值的转换非常简单：所有的对象（包括数组和函数）都转换为true。对于包装对象亦是如此，new Boolean(false)是一个对象而不是原始值，它将转换为true。 对象到字符串（object-to-String）和对象到数字(object-to-number)的转换是通过调用带转换对象的一个方法来完成的。一个麻烦的事实是，javascript对象有两个不同的方法来执行转换，并且接下来要讨论并且接下来要讨论的场景更加复杂。值得注意的是，这里提到的字符串和数字的转换规则只适用于本地对象（native fangf object）.宿主对象(例如：由web浏览器定义的对象)，根据各自的算法可以转换成字符串和数字。

所有的对象继承了两个转换方法。第一个是toString(), 它的作用是返回一个反映这个对象的字符串。默认的toString()方法并不会返回一个有趣的值。

({x:1,y:2}).toString() //=>"[object object]"

很多类定义了更多特定版本的toString()方法.

例如：数组类(Array class)的toString()方法将每个数组元素转换为一个字符串，并在元素之间添加逗号后并合成结果字符串。

函数类(Function class)的toString()方法返回这个函数的实现定义的表示方式。实际上，这里的实现方式是通常是将用户定义函数转换为javascript源代码字符串。

日期类(Date class)定义toString()方法返回一个可读的（可被javascript-parsable解析的）日期和事件字符串

RegExp class定义的toString()方法将RegExp对象转换为正则表达式直接量字符串。

Кода -копия выглядит следующим образом:

[1, 2, 3].toString(); //=> "1,2,3"

(function(x) {f(x);}).toString(); // =>"function(x){/nf(x); /n}"

//d+/g.toString(); //=> ///d+/g

new Date(2015, 0, 1).toString() //=>Thu Jan 01 2015 00:00:00 GMT+0800 (中国标准时间)

另外一个函数是valueOf(),这个方法的任务并未详细定义：如果存在任意原始值，它就默认将对象转换为表示它的原始值。对象是复合值，而且大多数对象无法真正表示一个原始值，数组、函数和正则表达式简单地继承了这个默认方法，调用这些类型的实例的的valueOf()方法简单地返回对象本身。日期类定义的valueOf()方法返回它的一个内部表示：1970年1月1日以来的毫秒数。

Кода -копия выглядит следующим образом:

var d = new Date(2015, 0, 1); //=>Thu Jan 01 2015 00:00:00 GMT+0800 (中国标准时间)

d.valueOf() //=>1420041600000

通过是用我们刚才讲解过的toString()和valueOf()方法，就可以做到对象到字符串和对象到数字的转换了。但在某些场景中，javascript执行了完全不同的对象到原始值的转换。这些特殊的场景在本节的最后会讲到。

javascript对象到字符串的转换经过了如下这些步奏

如果对象具有toString()方法，则调用这个方法。如果它返回一个原始值，javascript将这个值转换为字符串（如果本身不是字符串的话），并返回这个字符串结果。

如果对象没toString()方法，或者这个方法并不返回一个原始值，那么javascript会调用valueOf()方法。如果存在这个方法，则javascript调用它。如果返回值是原始值，javascript将责怪值转换为字符串。

9.变量声明。

在javascript程序中，使用一个变量之前应该先声明，变量是通过var来声明的，如下所示：

var i;

var sum;

也可以通过一个var关键字声明多个变量

var i,sun;

而且还可以将变量的初始值和变量声明和写在一起；

var message = "hello";

var i=0 ,j=0,k=0;

If the variable is specified in the var declaration statement, even though the variable is declared, its initial value is undefined before storing it a value. We noticed that the var statement can also be used in the for and fo/in loops, which can more concisely declare the loop variables used in the loop body syntax. Например:

Кода -копия выглядит следующим образом:

for (var i = 0; i < 10; i++) log(i);

for (var i = 0, j = 10; i < 10, j = 100; i++, j--) console.log(i * j)

for (var p in o) console.log(p);

If the variable is specified in the var declaration statement, even though the variable is declared, its initial value is undefined before storing it a value. We noticed that the var statement can also be used in the for and fo/in loops, which can more concisely declare the loop variables used in the loop body syntax. Например:

Кода -копия выглядит следующим образом:

var i=10;

i="ten";

10.变量作用域

一个变量的左右域（scope）是程序源代码中定义这个变量的区域，全局变量拥有全局作用域，在javascript代码中的任何地方都是定义。然而在函数内部声明变量只在函数体内有定义。他们是局部变量，作用是局部性的。函数参数也是局部变量，它们只在函数体内有定义。

在函数体内，局部变量的优先级高于同名的全局变量。如果在函数内声明一个局部变量或者函数参数中带有的变量和全局变量重名，那么全局变量就被局部变量所遮盖。

Кода -копия выглядит следующим образом:

var scope = "global"; //声明一个全局变量

function checkscope() {

var scope = "local"; //声明一个同名的局部变量

return scope;

}

checkscope(); //=>"local"

尽管在全局作用域编写代码时可以不写var语句，但声明局部变量时则必须使用var语句。

Кода -копия выглядит следующим образом:

scope = "global"; //声明一个全局变量,甚至不使用var来声明

function checkscope2() {

scope = "local"; //修改了全局变量

myscope = "local"; //这里显示式得声明了一个新的全局变量

return [scope, myscope]; //

}

checkscope2(); //=> ["local","local"]:产生了副作用

scope // =>"local"全局变量修改了

myscope //=> "local"全局命名空间搞乱了。

函数定义是可以嵌套的。由于每个函数都有它直接的作用域，因此会出现几个局部作用域嵌套的情况。

Кода -копия выглядит следующим образом:

var scope = "global scope"; //全局变量

function checkscope() {

var scope = "local scope"; //局部变量

function nested() {

var scope = "sested scope"; //嵌套作用域内的局部变量

return scope;

}

return nested();

}

checkscope() //=>"嵌套作用域" sested scope

я. Function scope and declaration in advance

在一些类似c语言的编程语言中，花括号内的每一段代码都具有各自的左右域，而且变量在声明他们的代码之外是不可见的我们称之为块级作用域(block scope),而javascript中没有块级作用域，javascript取而代之的使用了函数作用域(function scope);变量在声明它们的函数体以及这个函数体嵌套的任意函数体内都是有意义的。

如下代码，在不同的位置定义了ijk，他们都在同一个作用域内，这三个变量在函数体内均有定义的。

Кода -копия выглядит следующим образом:

function test(o) {

var i = 0; //i在整个函数体内均是定义的

if (typeif o == "object") {

var j = 0; //j在函数体内是有定义的，不仅仅是在这个代码段内

for (var k = 0; k < 10; k++) { //k在函数体内是有定义的，不仅仅是在循环内

console.log(k); //输出数字0-9

}

console.log(k); //k已经定义，输出10

}

console.log(j); //j已经定义了，但可能没有初始化。

}

javascript的函数作用域是指在函数内声明的所有变量在函数体内始终是可见的。有意思的是，这意味这变量在声明之前甚至已经可用。javascript的这个特性被非正式的称为声明提前（hoisting），即javascript函数里声明的所有变量(但不涉及赋值)都被提前至函数整体的顶部。如下代码：

Кода -копия выглядит следующим образом:

var scope = "global";

function f() {

console.log (Scope); //Output "undefined", not "global"

var scope = "local"; //变量在这里赋初始值，但变量本身在函数体内任何地方都是有定义的

console.log (Scope); //Output "local"

你可能误以为函数的第一行会输出"global",因为代码还没有执行到var语句声明局部变量的地方。其实不然，由于函数作用域的特性模具部变量在整个函数体内始终有定义的，也就是说，在函数体内局部变量覆盖了同名全局变量。尽管如此，只有在程序执行到var语句的时候，局部变量才能正真的被赋值。

因此，上述的过程等价于：将函数内的变量声明"提前"至函数顶部，同时变量初始化留在原来的位置：

Кода -копия выглядит следующим образом:

function f() {

var scope; //在函数的顶部声明了局部变量

console.log (Scope); //The variable exists, but its value is "undefined"

scope = "local"; //在这里将其初始化，并赋值

console.log (Scope); //Here it has the value we expect

}

在具有块级作用域的编程语言中，在狭小的作用域里让变量声明和使用变量的代码尽可能靠近彼此，通常来说，这是一个非常不错的编程习惯。由于在javascript中没有块级作用域，因此一些程序员特意将变量声明放在函数体顶部，而不是将声明放在靠近使用变量之处。这种做法使得他们的源代码非常清晰地反映了真实的变量作用域。

ii作为属性的变量

当声明一个javascript全局变量时面试及上是定义了全局对象的一个属性。见本文第三节。

当使用var声明一个变量时，创建的这个属性是不可配置的。见第六章第7节。也就是说这个变量无法通过delete运算符删除。可能你已经注意到了，如果你没有使用严格模式并给一个未声明的变量赋值的话。javascript会自动创建一个全局变量。以这种方式创建变量是全局对象正常的可配置属性。可以删除它们。

Кода -копия выглядит следующим образом:

var truevar = 1; //声明一耳光不可删除的全局变量

fakevar = 2; //创建全局对象的一个可删除的属性

this.fakevar2 = 3; //同上

delete truevar // =>false 变量并没有删除

delete fakevar //=>true 变量被删除

delete this.fakevar2 //=>true 变量被删除

javascript全局变量是全局对象的属性，这是在ECMAScript规范中强制规定的。对于局部变量则没有此规定，但我们可以想象得到，局部变量当做跟函数调用相关的某个对象的属性。ECMAScript3规范称对象为“调用对象”（call object）,ECMAScript5规定范称为“声明上下文对象”（declarative environment record）。javascript可以允许使用this关键字引用全局对象，却没有方法可以引用局部变量中存放的对象。这种存放局部变量的对象的特有性质，是一种对我们不可见的内部实现。然而，这些局部变量对象存在的观念是非常重要的。

iii作用域链

javascript是基于词法作用域的语言：通过阅读包含变量定义在内的舒航源码就能知道变量的作用域。

全局变量在程序中始终是都是有定义的。局部变量在声明它的函数体内以及其所嵌套的函数内始终是有定义的。