Java – это первый язык программирования, который я выучил (помимо HTML), и то, что я часто использую, чтобы услышать о JavaScript, было чем-то сродни:
JavaScript – это более простая Java, которая интерпретируется, а не компилируется, и используется в основном для веб-разработки.
Глядя на синтаксис, он выглядит достаточно похожим, но “под капотом”, похоже, есть некоторые основные различия.
JavaScript часто рассматривается как просто то, что вам нужно изучить вместе с HTML и CSS для веб-разработки, но раньше на него меньше смотрели как на мощный язык сам по себе.
Я вижу, что способ использования JavaScript сильно отличается от Java (и C#). Java и C# действительно используют объектно-ориентированный способ выполнения задач фиксированным способом, однако в JavaScript этот объектно-ориентированный стиль программирования гораздо более необязателен.
Как бы то ни было, я подумал, что напишу статью, посвященную JavaScript и его синтаксису, для тех, кто больше привык к более строгим объектно-ориентированным языкам, таким как Java и C#. Я включаю C# с тех пор, как узнал, что и я обнаружил, что это так похоже на Java.
Я пройдусь по нескольким очень коротким разделам, отметив некоторые особенности JavaScript. Я был бы признателен за то, что мне указали на эти вещи в начале, поэтому это и послужило источником вдохновения для этой короткой статьи.
Массивы в C# и Java фиксированы по типу и длине. Например:
int[] arr = new int[5];
Здесь мы можем заполнять только целыми числами.
Однако в JavaScript они могут быть любыми.
напр.
let arr = [5,"Hello", false, 5.1, true];
Достаточно справедливо, но есть и другие интересные вещи…
Зацени это.
- Ява
arr.length();
Будет 5.
- язык JavaScript
arr.Length();
Будет 5.
Теперь давайте попробуем это (все еще на JavaScript):
arr.foo = "bar"; arr.Length();
Длина все еще 5.
?? ?
Массивы JavaScript подобны специализированным “объектам”. Каждый элемент в “массиве” имеет ключ (от 0 до n). Атрибут длины будет изменен только в соответствии с этими конкретными парами ключ-значение (от 0 до n), а не с любыми другими добавленными… Это подводит нас к “объектам” JavaScript, о чем, возможно, следовало упомянуть ранее…
Объекты JavaScript в основном представляют собой пары ключ-значение… В некотором смысле они напоминают мне Хэш-карту Java или Словарь C#. Вот почему я написал “Объекты”, а не объекты в качестве названия этого раздела.
Объекты Java/C# можно представить следующим образом: экземпляры любого класса, у которого есть конструктор.
Например, строка в Java – это объект. Это создание экземпляра класса String, для создания объекта у этого объекта есть значение (сама строка) и различные методы, которые входят в состав этого объекта.
Java и C#, очевидно, более объектно-ориентированы в своем дизайне, JavaScript – в меньшей степени, хотя при желании можно программировать объектно-ориентированным способом.
Когда люди говорят об объектах на JavaScript, они могут привести такой простой пример:
var car = {type:"Fiat", model:"500", color:"white"};
Там у нас есть пары ключ-значение, которые мы называем “объектом”.
Теперь ключ может иметь функцию в качестве значения, и, следовательно, он обладает гибкостью объекта, обладая свойствами и методами (функциями), которыми обладает класс/объект Java/C#.
var и let – это два способа объявления переменных в JavaScript. Давайте исследуем…
Если вы введете a , например:
a = 1;
И a еще не определен, JavaScript просто интерпретирует это как:
var a = 1;
Так что far – это как значение JavaScript по умолчанию.
Сейчас если вы наберете еще раз:
var a = 2;
JavaScript по существу переопределил бы a и a станет 2.
Это не могло сработать для let. Если бы ты попытался убежать:
let a = 1; let a = 2;
Была бы ошибка, говорящая что-то вроде “переменная a уже объявлена”, как и следовало ожидать в Java/C#.
Также, если вы попытаетесь объявить var a , если вы уже объявили let a , возникнет проблема… a принимается. let имеет область действия блока, var имеет функциональную область действия.
let действует как переменные в Java или C#, var |/, с другой стороны, этого не делает.
Это потому, что мы можем бежать:
var a=1; var a=2; var c=3;
И не было бы никаких проблем. var могут переопределять друг друга, в то время как let (и const , к которым мы вернемся позже) как бы распределяются и занимают блок кода.
Я представляю себе var как кучу. Если вы поместите новый var поверх кучи, он переопределит остальные.
let будет действовать как переменная Java/C#.
Рассмотрим приведенный ниже бесполезный код JavaScript, чтобы показать, как работает определение области действия блоков в пусть (и const ), который точно так же работает в Java/C#:
{
let a=1;
// a === 1
{
let a=2;
// a === 2
{
let a = 3;
// a === 3
{
// a === 3
}
}
}
}
// a === undefined
Нечто универсальное среди языков, которые мы сегодня сравниваем, – это константа. В Java для этого используется модификатор final перед переменной.
напр.
final int i = 1;
Итак, я вижу const часто используется в JavaScript, поэтому это заслуживает отдельного раздела, хотя на самом деле consent не так уж сильно отличается от того, как он используется в Java.
Итак, сбивающая с толку вещь, возможно, заключается в том, что const (сокращение от constant) в некотором смысле, по-видимому, меняется. Что не может измениться, так это то, на что оно указывает. Что может измениться, так это сама вещь.
Таким образом, константа примитивных типов, таких как целые числа или логические значения, не изменится.
напр.
const aBool = true;
Однако мы можем поместить логическое значение в массив (или объект):
const aBool = [true];
Затем мы можем изменять его так сильно, как нам нравится:
aBool.pop(); aBool.push(false);
операционная
aBool[0] = false;
((книга теперь оценивается как [false])
Мы могли бы сделать то же самое с объектом.
const myBool = {value: true};
myBool.value = false;
Всякий раз, когда мы видим постоянно , мы не должны буквально думать о “константе” обычным способом, а просто о постоянном указателе!
В коде JavaScript мы видим const используется гораздо чаще, чем в Java. Это может быть связано с тем, что Java написана гораздо более объектно-ориентированным способом, и переменные часто не могут быть изменены так легко из-за принципа инкапсуляции. С другой стороны, разработчики JavaScript, похоже, гораздо больше полагаются на конструкцию вместо того, чтобы всегда выбирать использование пусть .
Я нахожу это необычным, поскольку, приходя с Java, вы, как правило, не так часто видите, как делается “final”.
Обычно люди используют его для таких вещей, как математические константы. и т.д.…
Я вижу const часто используется для функций, что для тех, кто использует Java, само по себе странно…
Так что думайте об этом так. Вещь, на которую указывает const , постоянна, но состояние этой вещи – нет! Однако на самом деле это то же самое для Java. Внутреннее состояние объекта, которому присвоена конечная переменная, может измениться, но сам объект всегда будет этим объектом.
Однако в Java все более предсказуемо. Да, значения массивов могут быть изменены, однако ни длина массивов, ни тип элементов в них не изменятся. То же самое и с объектами, “свойства” внутри объектов также останутся прежними, вы не сможете добавлять какие-либо новые переменные методов (функций). Не так с JavaScript, следовательно, const гораздо более универсален и используется чаще.
Кроме того, в Java это дополнительный модификатор, который необходимо использовать “final”, возможно, это тоже отпугивает людей от его использования чаще!
Хорошо, итак, вы можете получить функции “жирной стрелки” на Java и C# но они видны НАМНОГО меньше, чем в JavaScript, и они гораздо менее основные и универсальные в Java/C #.
Давайте так давайте разберемся в них. В C # это “лямбда-выражения”, и вы видите, как они выполняются (например) при использовании библиотеки LINQ. Однако в JavaScript вы могли бы написать все с помощью функций с жирными стрелками и никогда не писать ни одной функции “стандартным” способом, если бы захотели.
Пример “обычной” функции JavaScript.
function greetPerson(name, question)
{
return "Hello, "+name+ " "+question;
}
Это очень похоже на метод (он же функция), к которому мы привыкли в Java/C#.
То же самое, что и функция жирной стрелки, может быть:
const myFunction = () =>("Hello, "+name+ " "+question);
Вы когда-нибудь присваивали функцию переменной в Java или C#? У меня нет… Однако подумайте об этом, переменная const – это просто ссылка на функцию (т.Е. Имя), поэтому она делает то же самое…
Функции Fat arrow имеют то, что называется “неявным возвратом”, поэтому ожидается, что они что-то вернут, поэтому могут использоваться для хорошего сокращения.
Лично, хотя во многих ситуациях мне часто нравится мой многословный код в стиле “lego-block”, полный фигурных скобок…
В JavaScript вы будете снова и снова сталкиваться с функциями обратного вызова… Вот пример:
// declare a function
function greet(greeting = "hello")
{
return greeting;
}
Тогда мы могли бы убежать:
const f1 = greet; const f2 = greet();
Теперь f1 будет ссылкой на функцию . . f2 на самом деле будет строковым значением “hello”.
f1 – это функция обратного вызова. Итак, чтобы вызвать его, мы должны перейти f1.greet() или f1.greet(myParam) |/.
С другой стороны, в f2 функция уже была вызвана (что произойдет только один раз), и возвращаемый результат (в данном случае примитивная строка) сохраняется внутри.
Это может показаться банальным, но иногда это может сбить с толку людей, в том числе и меня.
Кроме того, мы можем вернуться здесь к нашим функциям с жирными стрелками и посмотреть их использование здесь.
const f1 = (greeting=hello) => greeting;
Таким образом, различие должно заключаться в имени между функцией, которая может быть “вызвана обратно”, и возвращаемым результатом функции.
Случаи, когда это важно, будут при работе с DOM и REACT в JavaScript.
Предположим, мы связаны с компонентом button в DOM, и мы назвали это button .
button.onClick(greet);
Будет работать, чтобы приветствовать человека при каждом нажатии кнопки.
Однако, если мы побежим
button.onClick(greet());
Наша кнопка ничего не будет делать при нажатии, так как функция приветствие вызывается при настройке свойства onClick.
great() по умолчанию возвращает “hello”. ” привет” – это не функция, и поэтому, по сути, ничего не происходит при нажатии кнопки.
Чтобы просмотреть наши функции с жирными стрелками, мы также можем перейти:
button.onClick(()=>console.log(greeting));
Мы не можем выполнять эти функции типа обратного вызова таким простым способом в Java.
Мы могли бы имитировать наш предыдущий f2, перейдя:
String f2 = greet();
Однако мы не можем просто присвоить функцию переменной. Однако мы могли бы создать объект, который мог бы вызывать функцию (или метод). По сути, это было бы просто созданием объекта на Java (или C#), затем созданием экземпляра этого объекта и запуском требуемого метода.
Greeter greeter = new Greeter(); greeter.greet();
Тем не менее, это не функция обратного вызова.
Так что деструктурирование – это то, чего я не вижу в Java и C#.
Итак, вот пример из REACT с использованием use Reducer. Неважно, что он делает, поскольку он довольно продвинутый, но это наглядный пример широко используемого деструктурирования.
const [state, dispatch] = useReducer(reducer, initialState);
Итак, здесь у нас есть функция use Reducer, которая принимает редуктор (который является функцией обратного вызова) и начальное состояние (которое может быть примитивным типом, массивом или объектом). Он возвращает два значения в массиве: [состояние, отправка] .
Это выглядит странно но, по сути, мы “разрушаем”, поэтому первое значение, возвращаемое в массиве, переходит в состояние, а второе значение – в отправку.
Точно так же мы могли бы написать следующее, и это сделало бы точно то же самое
const myArray = useReducer(reducer, initialState); const state = myArray[0]; const dispatch = myArray[1];
Теперь перейдем к более простому примеру:
[a,b] = [1,2];
a равно 1, b равно 2.
Если вы выполнили следующее:
[a,b,c] = [1,2];
a и b были бы одинаковыми но теперь у нас есть c также, который является неопределенным .
На этом мы завершаем наш краткий и случайный взгляд на JavaScript против Java/C#!
Оригинал: “https://dev.to/paradigmzero/javascript-is-weird-and-cool-comparing-it-with-the-object-orientated-languages-java-and-c-2ahe”