Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
56 changes: 24 additions & 32 deletions modules/40-define-functions/100-define-function/es/README.md
Original file line number Diff line number Diff line change
Expand Up @@ -13,9 +13,9 @@ console.log("Hello, JavaScript!");
Para no repetir la misma plantilla, se la puede envolver en una función propia que reciba un parámetro e imprima la cadena necesaria:

```javascript
function sayHello(name) {
const sayHello = (name) => {
console.log(`Hello, ${name}!`);
}
};
```

Ahora se la puede llamar con distintos argumentos:
Expand All @@ -31,37 +31,37 @@ Parece que el código no se ha reducido, pero apareció otra ventaja: si la func
## La sintaxis de la definición

```javascript
function nombreDeLaFuncion(parámetros) {
const nombreDeLaFuncion = (parámetros) => {
cuerpo;
}
};
```

```text
function greet(name) { ← palabra clave, nombre y parámetro
return 'Hello, ' + name; ← cuerpo de la función
}
const greet = (name) => { ← nombre, parámetro y flecha
return 'Hello, ' + name; ← cuerpo de la función
};
```

La definición empieza con la palabra clave `function`, después va el nombre de la función (con las mismas reglas que las variables), entre paréntesis la lista de parámetros separados por comas, y el cuerpo de la función se encierra entre llaves `{}`.
La definición tiene dos partes. A la derecha del signo `=` está la propia función. Entre paréntesis va la lista de parámetros separados por comas, después la flecha `=>`, y el cuerpo de la función se encierra entre llaves `{}`. A la izquierda está el nombre, y la función se guarda en una constante con las mismas reglas que cualquier otro valor. Por eso al final de la definición va un punto y coma, igual que después de una asignación normal.

## Definir una función no significa llamarla

Definir una función no ejecuta su código. El cuerpo se ejecutará solo al llamarla. Mira el ejemplo:

```javascript
function sayHi() {
const sayHi = () => {
console.log("Hi!");
}
};

console.log("El programa continúa…");
```

Aquí la función `sayHi()` está definida, pero su cuerpo no se ejecuta: en la pantalla aparecerá solo `El programa continúa…`. Para que `sayHi()` funcione, hay que llamarla de forma explícita:

```javascript
function sayHi() {
const sayHi = () => {
console.log("Hi!");
}
};

sayHi(); // => Hi!
console.log("El programa continúa…");
Expand All @@ -72,11 +72,11 @@ console.log("El programa continúa…");
Implementemos una función que **calcula e imprime la media aritmética** de dos números. La media aritmética es la suma de los números dividida por su cantidad. Por ejemplo, la media de 6 y 4: `(6 + 4) / 2 = 5`.

```javascript
function printAverage(a, b) {
const printAverage = (a, b) => {
const total = a + b;
const average = total / 2;
console.log(average);
}
};

printAverage(6, 4); // => 5
```
Expand All @@ -88,9 +88,9 @@ Aquí `a` y `b` son los parámetros de entrada, `total` contiene su suma, `avera
El nombre de un parámetro puede ser cualquiera; lo importante es que refleje el sentido del valor que llegará dentro. Con el código de fuera no está relacionado de ninguna manera:

```javascript
function getLastChar(str) {
const getLastChar = (str) => {
return str[str.length - 1];
}
};

// Dentro de la función str será igual a 'Winter is coming'.
// El nombre de la variable de fuera no está ligado al nombre del parámetro
Expand All @@ -110,29 +110,21 @@ console.log("google".replace("mo", "go")); // => google

## Otras formas de escribir funciones

Una función no solo se puede declarar con `function`: también se puede escribir como un valor y asignarla a una constante:
En la documentación y en el código de otras personas la función se define a menudo con la palabra clave `function`:

```javascript
const sayHello = function (name) {
console.log(`Hello, ${name}!`);
};

sayHello("Hexlet"); // => Hello, Hexlet!
```

Esa forma se llama expresión de función. Fíjate en el punto y coma del final: aquí tenemos una asignación normal a una constante, no una declaración de función.

La expresión de función tiene una forma corta, la de flecha. En ella la palabra `function` se sustituye por la flecha `=>`, que se coloca después de la lista de parámetros:
<!-- lint-code-blocks: skip — объявление function показано как другая форма записи, правило js-function-declaration переписало бы его в стрелочную -->

```javascript
const sayHello = (name) => {
```text
function sayHello(name) {
console.log(`Hello, ${name}!`);
};
}

sayHello("Hexlet"); // => Hello, Hexlet!
```

Para nuestras tareas las tres formas son equivalentes: la función se define y luego se llama por su nombre. La forma de flecha es la que más aparece en JavaScript, por eso más adelante en el curso los ejemplos están escritos así. Una lección aparte de este módulo mostrará cómo acortarla todavía más.
Esa forma se llama declaración de función. También aparece la expresión de función `const sayHello = function (name) { … };`, que está construida como la función de flecha, solo que en lugar de la flecha lleva la palabra `function`.

Para nuestras tareas las tres formas son equivalentes, porque la función se define y luego se llama por su nombre. La forma de flecha es la que más aparece en JavaScript, por eso en el curso los ejemplos están escritos así. Una lección aparte de este módulo mostrará cómo acortarla todavía más.

## Reutilización y legibilidad

Expand Down
4 changes: 2 additions & 2 deletions modules/40-define-functions/100-define-function/index.js
Original file line number Diff line number Diff line change
@@ -1,7 +1,7 @@
// BEGIN
function sayHello() {
const sayHello = () => {
console.log("Hello, World!");
}
};
// END

export default sayHello;
56 changes: 24 additions & 32 deletions modules/40-define-functions/100-define-function/ru/README.md
Original file line number Diff line number Diff line change
Expand Up @@ -13,9 +13,9 @@ console.log("Hello, JavaScript!");
Чтобы не повторять один и тот же шаблон, его можно оформить в виде своей функции, которая принимает параметр и печатает нужную строку:

```javascript
function sayHello(name) {
const sayHello = (name) => {
console.log(`Hello, ${name}!`);
}
};
```

Теперь её можно вызывать с разными аргументами:
Expand All @@ -31,37 +31,37 @@ sayHello("JavaScript"); // => Hello, JavaScript!
## Синтаксис определения

```javascript
function имяФункции(параметры) {
const имяФункции = (параметры) => {
тело;
}
};
```

```text
function greet(name) { ← ключевое слово, имя и параметр
return 'Hello, ' + name; ← тело функции
}
const greet = (name) => { ← имя, параметр и стрелка
return 'Hello, ' + name; ← тело функции
};
```

Определение начинается с ключевого слова `function`, затем идёт имя функции (по тем же правилам, что и у переменных), в скобках — список параметров через запятую, а тело функции заключается в фигурные скобки `{}`.
Определение состоит из двух частей. Справа от знака `=` записана сама функция. В скобках идёт список параметров через запятую, после него стрелка `=>`, а тело функции заключается в фигурные скобки `{}`. Слева стоит имя, и функция сохраняется в константу по тем же правилам, что и любое другое значение. Поэтому в конце определения ставится точка с запятой, как после обычного присваивания.

## Определить функцию — не значит вызвать её

Определение функции не запускает её код. Тело выполнится только при вызове. Посмотрите на пример:

```javascript
function sayHi() {
const sayHi = () => {
console.log("Hi!");
}
};

console.log("Программа продолжается…");
```

Здесь функция `sayHi()` определена, но её тело не выполняется — на экран попадёт только `Программа продолжается…`. Чтобы `sayHi()` сработала, её нужно явно вызвать:

```javascript
function sayHi() {
const sayHi = () => {
console.log("Hi!");
}
};

sayHi(); // => Hi!
console.log("Программа продолжается…");
Expand All @@ -72,11 +72,11 @@ console.log("Программа продолжается…");
Реализуем функцию, которая **вычисляет и печатает среднее арифметическое** двух чисел. Среднее арифметическое — это сумма чисел, делённая на их количество. Например, среднее от 6 и 4: `(6 + 4) / 2 = 5`.

```javascript
function printAverage(a, b) {
const printAverage = (a, b) => {
const total = a + b;
const average = total / 2;
console.log(average);
}
};

printAverage(6, 4); // => 5
```
Expand All @@ -88,9 +88,9 @@ printAverage(6, 4); // => 5
Имя параметра может быть любым — главное, чтобы оно отражало смысл значения, которое попадёт внутрь. С внешним кодом оно никак не связано:

```javascript
function getLastChar(str) {
const getLastChar = (str) => {
return str[str.length - 1];
}
};

// Внутри функции str будет равна 'Winter is coming'.
// Имя переменной снаружи не связано с именем параметра
Expand All @@ -110,29 +110,21 @@ console.log("google".replace("mo", "go")); // => google

## Другие формы записи

Функцию можно не только объявить через `function`, но и записать как значение и присвоить константе:
В документации и в чужом коде функцию часто определяют через ключевое слово `function`:

```javascript
const sayHello = function (name) {
console.log(`Hello, ${name}!`);
};

sayHello("Hexlet"); // => Hello, Hexlet!
```

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

У функционального выражения есть короткая форма, стрелочная. Слово `function` в ней заменяется на стрелку `=>`, которая ставится после списка параметров:
<!-- lint-code-blocks: skip — объявление function показано как другая форма записи, правило js-function-declaration переписало бы его в стрелочную -->

```javascript
const sayHello = (name) => {
```text
function sayHello(name) {
console.log(`Hello, ${name}!`);
};
}

sayHello("Hexlet"); // => Hello, Hexlet!
```

Для наших задач все три записи равнозначны: функцию определяют, а потом вызывают по имени. Стрелочная форма в JavaScript встречается чаще остальных, поэтому дальше в курсе примеры записаны именно так. Отдельный урок этого модуля покажет, как сократить её ещё сильнее.
Такую запись называют объявлением функции. Встречается и функциональное выражение `const sayHello = function (name) { … };`, которое устроено как стрелочная функция, только вместо стрелки в нём стоит слово `function`.

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

## Переиспользование и читаемость

Expand Down
24 changes: 12 additions & 12 deletions modules/40-define-functions/150-return/es/README.md
Original file line number Diff line number Diff line change
Expand Up @@ -7,9 +7,9 @@ Para que una función entregue un resultado se usa la palabra clave especial `re
Aquí tienes una función que pone el texto en mayúsculas:

```javascript
function shout(name) {
const shout = (name) => {
return name.toUpperCase();
}
};

const result = shout("hexlet");
console.log(result); // => HEXLET
Expand All @@ -26,14 +26,14 @@ A diferencia de `console.log()`, `return` no imprime nada. Simplemente devuelve

```javascript
// Esta función imprime, pero no devuelve nada
function printSum(a, b) {
const printSum = (a, b) => {
console.log(a + b);
}
};

// Esta función devuelve el resultado
function getSum(a, b) {
const getSum = (a, b) => {
return a + b;
}
};

// El resultado devuelto se puede usar después
const sum = getSum(3, 4);
Expand All @@ -45,9 +45,9 @@ console.log(sum * 2); // => 14
En `return` normalmente se indica una **expresión**, que primero se evalúa y después se pasa el resultado hacia fuera:

```javascript
function fullName(first, last) {
const fullName = (first, last) => {
return `${first} ${last}`;
}
};

const name = fullName("Aria", "Stark");
console.log(name); // => Aria Stark
Expand All @@ -60,11 +60,11 @@ Primero se evalúa la plantilla de cadena, y ya el valor listo se devuelve hacia
A veces en el cuerpo de la función hay que dar varios pasos antes de obtener el resultado. Entonces se escriben varias líneas, y al final se usa `return`. Por ejemplo, una función que formatea un nombre: quita los espacios de los extremos y pasa las letras a mayúsculas.

```javascript
function formatName(name) {
const formatName = (name) => {
const clean = name.trim();
const uppercased = clean.toUpperCase();
return uppercased;
}
};

console.log(formatName(" hexlet ")); // => HEXLET
```
Expand All @@ -74,10 +74,10 @@ console.log(formatName(" hexlet ")); // => HEXLET
Cuando la ejecución llega a `return`, la función termina de inmediato. Todo lo que esté escrito después, dentro de la función, **no se ejecutará**:

```javascript
function example() {
const example = () => {
return "listo";
console.log("este código nunca se ejecutará");
}
};

console.log(example()); // => listo
```
Expand Down
4 changes: 2 additions & 2 deletions modules/40-define-functions/150-return/index.js
Original file line number Diff line number Diff line change
@@ -1,8 +1,8 @@
function truncate(text, length) {
const truncate = (text, length) => {
// BEGIN
const result = `${text.slice(0, length)}...`;
return result;
// END
}
};

export default truncate;
Loading
Loading