Напишите впереди
Сегодня я хочу проверить знание типов узлов и какие знания я хочу суммировать. Я видел статью в Google, но оригинальная ссылка исчезла. Я вытащил эту статью в снимке. Если у оригинального автора есть какие -либо вопросы, пожалуйста, свяжитесь со мной!
Эта статья основана на некоторых JS, и эксперты автоматически пропустят ее! Я не писал много о JS раньше, и этот аспект относительно слаб, поэтому я также столкнулся с проблемами при написании узлов. Вот добавка, насколько мне известно!
текст
Основой node.js является JavaScript, язык сценариев. Одной из общих черт большинства языков сценариев является «слабый тип».
В отличие от PHP, даже если в PHP есть новые переменные, нет необходимости объявлять их, в то время как JavaScript по -прежнему нуждается в VAR, чтобы объявить их. Этот VAR охватывает все типы значений, такие как int, string, char и т. Д. В C ++ и даже функциях.
Весь контент в этой статье и следующую статью отредактированы с использованием VIM в Linux или Cygwin (если нет, преобразуйте его в свой собственный метод), а затем просмотрите результаты в командной строке.
Базовый синтаксис
Переменная объявление
В C/C ++ мы объявляем такие переменные, как это:
`` C ++
Кода -копия выглядит следующим образом:
void foo () {}
int a = 0;
char b = 'a';
float c = 1,0f;
void (*d) () = foo; /// <Забыл, если это то, что я написал, короче говоря, это указатель функции
И в node.js это выглядит так:
`` javascript
Кода -копия выглядит следующим образом:
функция foo () {}
var a = 0;
var b = 'a';
var c = 1,0;
var d = foo;
Таким образом, независимо от того, какой это тип переменной, он решается с помощью var in node.js.
Заявление петли
для… я
Этот оператор цикла в основном такой же, как C/C ++, оба
`` C ++
Кода -копия выглядит следующим образом:
для (int i = 0; i <foo; i ++)
{
// ...
}
А так как node.js - слабый тип, просто необходимость:
`` javascript
Кода -копия выглядит следующим образом:
для (var i = 0; i <foo; i ++) {
// ...
}
для ... в
Это пост-формовый цикл, похожий на Foreach PHP.
Например, у нас есть объект JSON следующим образом:
JavaScript
Кода -копия выглядит следующим образом:
var foo = {
"Привет, мир",
"Узел": "JS",
"Blahblah": "бар"
};
В настоящее время мы можем использовать для ... в промежутке:
JavaScript
Кода -копия выглядит следующим образом:
for (var in foo) {
console.log (key + ":" + foo [key]);
}
Если мы введем следующую команду в командной строке:
Кода -копия выглядит следующим образом:
$ node foo.js
На экране будет отображаться следующий контент:
Кода -копия выглядит следующим образом:
привет
: мир
Узел: JS
Blahblah: бар
Совет: Из вышесказанного, для ... в утверждении используется для прохождения ключевых имен объектов, массивов и объектов JSON, не обеспечивая обход ключевой стоимости. Если вы хотите получить значение ключа, вы можете получить его только в форме Foo [<текущее имя ключа>]. Это все еще немного отличается от PHP Foreach.
пока ... делай, делай ...
Я не буду так много объяснить, это не большая разница от других языков. Это не что иное, как это, если есть объявление переменной, этого достаточно, чтобы использовать VAR.
Операторы
+, -, *, /
Это относится к этим операторам, следует обратить внимание на +. Он может действовать как на строках, так и на численных операциях. Хотя языки слабого типа говорят, что типы слабые, числа иногда могут появляться в форме строк, а струны иногда могут появляться в форме численных значений, но при необходимости вам все равно нужно говорить о том, какой это тип. Мы можем использовать следующий код, чтобы увидеть результаты:
Кода -копия выглядит следующим образом:
var a = "1";
var b = 2;
console.log (a + b);
console.log (parseint (a) + b);
Здесь Parseint-это встроенная функция node.js, которая используется для анализа строки в переменную типа int.
Приведенный выше результат выполнения кода:
Кода -копия выглядит следующим образом:
12
3
ПРИМЕЧАНИЕ. Результат первой консоли. LOG составляет 12. Поскольку a - это строка, B также добавляется в качестве строки по системе. Результатом является то, что две строки приклеены вместе и становятся 12. Результат второй консоли. Log 3, потому что мы конвертируем первый тип a в INT и добавляем две переменные типа INT, то есть добавить значения, и, конечно, результат - 3.
==, ==,! =,! ==
Вот момент, чтобы объяснить, что когда длина этого логического оператора составляет 2 (==,! =), Это только определяет, является ли внешнее значение одинаковым, но не определяет тип. нравиться
Кода -копия выглядит следующим образом:
var a = 1, b = "1";
console.log (a == b);
Результат его вывода верно. Но если мы добавим равный знак, когда сделаем суждения в середине, то мы сделаем строгое суждение. Это будет правдой только тогда, когда тип и значение одинаковы, иначе это будет ложным. То есть
Кода -копия выглядит следующим образом:
var a = 1, b = "1";
console.log (a === b);
Когда возвращается результат, является ложным, потому что A имеет тип int, а B - строка.
Кстати, давайте поговорим о условном заявлении. На самом деле, если здесь ничем не отличается от других языков, это просто проблема из двух равных знаков и трех равных знаков для нескольких логических операторов. Так что я не буду делать много утомительного заявления.
тип
Здесь я буду рассматривать это как оператор, а не функцию.
Функция этого оператора состоит в том, чтобы судить тип переменной и вернуть строку, то есть имя типа. Вы узнаете, если вы выполните следующий код:
Кода -копия выглядит следующим образом:
функция foo () {}
var a = 0;
var b = 'Shh ~ Яйцо -цветочный суп спит. ';
var c = 1,0;
var d = foo;
var e = {"a": a};
var f = [1, 2, 3];
var g = null;
var h = не определен;
console.log (typeof a);
console.log (typeof b);
console.log (typeof c);
console.log (typeof d);
console.log (typeof e);
console.log (typeof f);
console.log (typeof g);
console.log (typeof h);
Результатом выполнения здесь будет:
Кода -копия выглядит следующим образом:
число
нить
число
функция
объект
объект
объект
неопределенный
NULL, неопределенная, Нэн
В JavaScript есть три специальных значения, как показано в заголовке. Каждый может быть знаком с первым. Есть также C/C ++, но он капитализируется, и его сущность едина.
`` C ++
Определите NULL 0
В JavaScript значения этих трех значений различны.
### нулевой ###
NULL - это особый объект, который примерно означает пуст. Например:
var a = null;
Каждый может понять это, поэтому я не буду объяснять это. Но в отличие от C/C ++, этот нуль не равен 0.
### неопределенный ###
Эта вещь означает, что эта переменная не объявлена. Чтобы лучше отличить NULL, наш пример кода заключается в следующем:
`` javascript
Кода -копия выглядит следующим образом:
var a = {
"Foo": Null
};
console.log (a ["foo"]);
console.log (a ["bar"]);
В приведенном выше коде мы делаем значение ["foo"] пустым, то есть ноль. И это не объявлено вообще, это даже не пусто. Каждый должен был догадаться о результатах выходных данных:
Кода -копия выглядит следующим образом:
нулевой
неопределенный
Нэн
Это пустое значение, специальное число. Его полное имя не число. Это немного странно. Вы можете понять его как переменную типа числа, которая не является числовой формой или переменной типа числа с ошибками.
Это часто происходит при ошибках численной операции с плавающей точкой (например, разделение на 0), или даже пользователь может сделать переменную, равную NAN, чтобы вернуть значение ошибки, чтобы все знали, что функция имела ошибку в работе.
Небольшой Разное
Другие оставшиеся утверждения аналогичны другим существующим языкам, таким как переключение, переключение, продолжение и т. Д.
Тип переменной
В этом разделе в основном рассказывается о объектах JavaScript, а другие типы почти одинаковы.
Базовый тип
Основные типы, содержащиеся в node.js, почти следующие:
число
нить
логический
множество
Первые три типа могут быть назначены непосредственно, а назначение массива является лишь справочным назначением. Если определенное значение изменяется в новой переменной, значение старой переменной также изменится. Вы можете напрямую попробовать следующий код:
JavaScript
var foo = [1, 2, 3];
var bar = foo;
бар [0] = 3;
console.log (foo);
Это приводит к:
JavaScript
[3, 2, 3]
Другими словами, если массив скопирован в новый массив, его нельзя использовать для непосредственного назначения значений, но должен быть «глубоко скопирован».
Здесь нам нужно поговорить о трех способах создания массива.
Первый тип:
JavaScript
Кода -копия выглядит следующим образом:
var dog = new Array ();
собака [0] = "shh ~";
собака [1] = "яичный цветок";
собака [2] = "Сон";
Второй тип:
JavaScript
Кода -копия выглядит следующим образом:
var dog = new Array ("Shh ~", "Яичный цветок", "Сон");
Четвертый тип:
JavaScript
Кода -копия выглядит следующим образом:
var dog = [
"Шш ~",
"Яичный цветочный суп",
"Сон"
];
Я лично предпочитаю третий способ написания, который является относительно кратким.
JSON Objects
Здесь я вынимаю объект JSON отдельно вместо того, чтобы классифицировать его как объект JavaScript. Если я думаю, что я немного вводит в заблуждение, я могу пропустить этот раздел напрямую.
Мое различие между объектами JSON и объектами JavaScript состоит в том, используется ли оно для хранения только данных, а не для экземпляров класса. На самом деле, сущность JSON - это обозначение объекта JavaScript.
Для получения дополнительной информации о JSON, пожалуйста, энциклопедии самостоятельно.
Объявление объекта json в node.js очень просто:
JavaScript
Кода -копия выглядит следующим образом:
var dog = {
"Pre": "Shh ~",
"sub": {
«Имя»: «Яичный цветочный суп»,
"Act": "Sleep",
«Время»: 12
},
«SUF»: [«Я сказал», «Спит», «Спит»]
};
Есть два способа получить значение ключа определенного ключа имени в объекте JSON. Первый - подключить его с точками, а второе - использовать кронштейны:
JavaScript
Кода -копия выглядит следующим образом:
собака
.pre;
собака ["pre"];
ПРИМЕЧАНИЕ. При использовании точек выше, ключ в JSON находится напрямую. Если вы относитесь к клавишу как к переменной, вы можете попробовать его только с помощью собаки [ключ]: теперь вы можете попробовать его самостоятельно и использовать для ... в том, чтобы пройти объект JSON выше. Не забудьте использовать Typeof ~
Основание класса (объект)
Строго говоря, класс Node.js не может считаться классом. На самом деле, это всего лишь набор функций, добавляя некоторые переменные члена. Его сущность на самом деле является функцией.
Однако, ради здравого смысла, мы будем называть его «классом» следующим и позже, а созданный на основе называется «объект».
Поскольку класс имеет много функций, или его сущность является функцией, мы можем поговорить о основаниях функции, когда мы не будем осторожны.
Декларация и экземпляры классов
Объявление класса очень просто, не смейтесь:
JavaScript
функция foo () {
// ...
}
Хорошо, мы написали класс Foo.
Истинно или фальшивый? ! настоящий.
Не верите в это? Если вы не верите в это, вы можете ввести код и прочитать его:
JavaScript
var bar = new foo ();
Не рассматривайте это как на функцию, если написано в такой форме (новой), это экземпляр этого класса.
И этот так называемый Foo () на самом деле является конструктором этого класса Foo ().
Переменные участника
Есть два хороших способа получить переменные участника.
Первый - это использовать это. <Имя переменной> В конструкторе класса или в любом конструкторе. Вы можете объявить переменную участника в любое время, и она не повлияет на использование снаружи. В любом случае, даже если вы используете его, когда он не будет объявлен, будет неопределенным, чтобы поддержать его. Итак, это первый метод:
Кода -копия выглядит следующим образом:
JavaScript
функция foo () {
this.hello = "world";
}
ПРИМЕЧАНИЕ. Это переменная члена вызова класса только при добавлении, в противном случае это всего лишь локальная переменная в функции. Необходимо различить, есть ли сфера действия этой переменной.
Второй метод состоит в том, чтобы объявить его вне конструктора или любой функции члена, а его формат - <имя класса> .prototype. <Имя переменной>:
JavaScript
Кода -копия выглядит следующим образом:
функция foo () {
// ...
}
foo.prototype.hello = "world";
Независимо от того, какой из вышеперечисленного метода является объявлением переменных членов, мы можем увидеть эффект:
JavaScript
Кода -копия выглядит следующим образом:
var bar = new foo ();
console.log (bar.hello);
Вы даже можете изменить этот класс таким образом:
JavaScript
Кода -копия выглядит следующим образом:
функция foo () {
this.hello = "world";
}
foo.prototype.hello = "яичный цветок";
Затем используйте приведенный выше код, чтобы вывести его.
Подумайте о том, почему выход - это мир, а не яичный суп.
Конструктор
Мы сказали, что Foo () на самом деле является конструктором. Затем, очевидно, мы можем передать параметры конструктору, поэтому у нас есть следующий код:
JavaScript
Кода -копия выглядит следующим образом:
// код 2.1
функция foo (hello) {
if (hello === undefined) {
this.hello = "world";
} еще {
this.hello = hello;
}
}
Мы видим странное суждение на нем, если (привет === не определен). Какое использование этого суждения? Первая возможность состоит в том, что разработчик специально отправил неопределенную боль в боли. В настоящее время это не определен.
Есть другая ситуация. С самого начала мы сказали, что JavaScript-это язык слабого типа. На самом деле, это не просто слабый тип, но и параметры передачи также очень невозможны. Вы можете пройти более или менее (до тех пор, пока вы гарантируете, что программа не допускает никаких ошибок, когда вы проходите более или менее), в принципе все в порядке. Параметры нескольких проходов будут автоматически игнорироваться, в то время как параметры нескольких проходов будут дополнены неопределенным.
Просто посмотрите на следующий код, и вы поймете:
JavaScript
Кода -копия выглядит следующим образом:
// подключить код 2.1 на
var bar1 = new foo ();
var bar2 = new foo ("яичный цветок");
Пожалуйста, выведите две переменные Hello в баре самостоятельно, и вы обнаружите, что один - мир, а другой - яичный суп. Очевидно, что когда наш первый BAR1 был объявлен, он автоматически рассматривался как node.js:
JavaScript
Кода -копия выглядит следующим образом:
var bar1 = new Foo (не определен);
Так что есть поговорка, что это мир.
Кроме того, в этом конструкторе мы видим, что в этом классе есть параметр, и в этом классе есть переменная -член, и в этом классе. Тем не менее, мы уже говорили, что сфера действия различна, когда есть это, а это не так. Этот параметр используется только в конструкторе, в то время как тот, который с этим является переменной. Используйте это, чтобы немедленно различить их, так что это не имеет значения, даже если такое же имя.
Функции участника
Объявление функции участника
Объявление функции члена аналогична второму методу объявления переменной элемента, то есть <имя класса> .prototype. <Имя функции> = <function>;
JavaScript
Кода -копия выглядит следующим образом:
// подключить код 2.1 на
Функция Sethello (Hello) {
this.hello = hello;
}
foo.prototype.sethello = sethello;
bar1.sethello ("яичный торт");
Поскольку вышеупомянутый код очевиден, мы реализуем функцию Sethello класса Foo, с помощью которой мы можем изменить значение foo.hello.
Но разве это не сложно писать так? Далее я расскажу о важной функции функций JavaScript.
★ Анонимные функции ★
Много раз, некоторые из наших функций ссылаются только или называются только в одном месте, поэтому слишком полезно дать эту функцию имя, и нет необходимости, поэтому мы можем временно написать эту функцию и напрямую спросить человека, который ссылается на ее ссылку, и человека, который называет ее, чтобы вызвать ее. Следовательно, функция может опустить имя функции, например:
JavaScript
Кода -копия выглядит следующим образом:
function (hello) {
this.hello = hello;
}
Что касается того, как это цитировать или назвать это? Если приведенный выше класс должен быть указан, он написан так:
JavaScript
Кода -копия выглядит следующим образом:
foo.prototype.sethello = function (hello) {
this.hello = hello;
}
Этот метод написания такой же, как объявление функции участника, и сохраняет много кода. И на самом деле, в основном объявление функций членов класса объявляется таким образом анонимных функций.
Что касается того, как сделать анонимные функции? Обычно это написано так, когда прохождение функции, которую вызывается только определенной функцией.
Например, у нас есть прототип функции:
JavaScript
Кода -копия выглядит следующим образом:
/**
* Мы проведем две переменные A и B,
* После расчета значения A+B передайте его Func (NUM)
* Перейти к выводу
*/
Функция sumab (a, b, func) {
var c = a + b;
Func (A, B, C);
}
Например, у нас есть две версии выходных функций, одна - китайская вывод, а другая - английский выход. Поэтому, если мы не используем анонимные функции:
JavaScript
Кода -копия выглядит следующим образом:
Функция zh (a, b, sum) {
Значение консоли.log (a + " +" + b + "IS:" + sum);
}
функция en (a, b, sum) {
console.log (a + "plus" + b + " - + sum);
}
Sumab (1, 2, ZH);
Sumab (3, 4, en);
Выполните этот код один раз, и вывод будет:
Значение 1 + 2 равна: 3
3 плюс 4 - 7
Если такой код находится в форме анонимных функций, это будет:
JavaScript
Кода -копия выглядит следующим образом:
sumab (1, 2, function (a, b, sum) {
Значение консоли.log (a + " +" + b + "IS:" + sum);
});
sumab (3, 4, function (a, b, sum) {
console.log (a + "plus" + b + " - + sum);
});
Эта форма обычно используется в функциях обратного вызова. Механизм обратного вызовов является сущностью node.js или javascript. Я представлю его в будущих главах.
Как объявить анонимную функцию в объявлении функции члена
Хотя я говорил об этом в предыдущем разделе, я просто расскажу об этом снова.
Обычно, когда мы объявляем функцию члена класса, мы используем анонимные функции, чтобы объявить ее, потому что в любом случае, эта функция является просто функцией члена этого класса и не будет ссылаться или вызоваться отдельно в других местах, поэтому доступен следующий код:
JavaScript
Кода -копия выглядит следующим образом:
// подключить код 2.1 на
foo.prototype.sethello = function (hello) {
this.hello = hello;
}
Таким образом, у нас есть функция Sethello в классе Foo.
2.3.4. Класс произвольный
Это снова моя чушь. Так называемая случайность классов означает, что в JavaScript вы можете изменить свой класс в любом месте, что имеет определенное сходство с Ruby.
Например, строка на самом деле является классом, с такими переменными членами, как длина, и функции -члена, такие как Indexof и substr. Но если мы думаем, что некоторые части этой строки не являются идеальными и хотим добавить свой собственный метод, то мы можем добавить к ней функцию, например:
JavaScript
Кода -копия выглядит следующим образом:
String.prototype.sb = function () {
var newsstr = "";
for (var i = 0; i <this.length; i ++) {
if (i % 2 === 0) newsr += "s";
else newsr += "b";
}
вернуть Newsr;
};
Значение этой функции состоит в том, чтобы заполнить строку, чтобы попасть в воплощение SB.
Давайте проверим это:
Кода -копия выглядит следующим образом:
var str = "Shh ~ яичный цветочный суп спит.";
console.log (str.sb ());
Вы получите следующий результат:
SBSBSBSBSBSBS
Если вы говорите: «Shhh ~ яйцо -цветок спит». Ваш компьютер ругает вас за то, что вы дурак четыре с половиной половины. (Разбить это быстро)
3. Прикреплено
3.1. Глубокая копия
Так называемая глубокая копия заключается в создании нового массива или объекта самостоятельно и вручную скопировать основные значения переменных типа в массиве источников или объекта один за другим, вместо того, чтобы просто принимать ссылки на массив исходных источников или объект. Таким образом, это включает в себя рекурсивный вызов или что -то в этом роде.
Ниже приведена функция глубокой копии, которую я реализовал. Вы можете написать одну из своих собственных и добавить его в свой собственный Node.js Base Base.
JavaScript
Кода -копия выглядит следующим образом:
функция CloneObject (src) {
var dest = {};
for (var key in src) {
if (typeof src === "Object") dest [key] = cloneObject (src [key]);
else dest [key] = src [key];
}
вернуть Дест;
}