export const getfilesize = (bytes, decimals = 2) => {
    if (bytes === 0){ 
        return '0 Bytes';
    }else{
        const k = 1024;
        const dm = decimals < 0 ? 0 : decimals;
        const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];
        const i = Math.floor(Math.log(bytes) / Math.log(k));
        return parseFloat((bytes / Math.pow(k, i)).toFixed(dm)) + ' ' + sizes[i];

    }
}

Я заметил несколько ответов, в которых упоминалось, что использование параметров по умолчанию не переносимо для других браузеров, но справедливо отметить, что вы можете использовать транспилеры, такие как Babel, для преобразования вашего кода в синтаксис ES5 для браузеров с ограниченной поддержкой для современных функций JS.

Так это:

function read_file(file, delete_after = false) {
  // Code
}

будет транслироваться как это (попробуйте это в Babel REPL -> https://babeljs.io/repl/):

"use strict";

function read_file(file) {

  var delete_after =
    arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
  
  //Code...

}

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

Да - доказательство:

function read_file(file, delete_after = false) {
  // Code
  console.log({file,delete_after});
}



// TEST
read_file("A");
read_file("B",true);
read_file("C",false);

Просто чтобы продемонстрировать мои навыки (смеется), вышеуказанная функция может быть написана даже без названных аргументов, как показано ниже:

ES5 и выше

function foo() {
    a = typeof arguments[0] !== 'undefined' ? a : 42;
    b = typeof arguments[1] !== 'undefined' ? b : 'default_b';
    ...
}

ES6 и выше

function foo(...rest) {
    a = typeof rest[0] !== 'undefined' ? a : 42;
    b = typeof rest[1] !== 'undefined' ? b : 'default_b';
    ...
}

Звуки будущего

В будущем вы сможете «распространять» один объект на другой (в настоящее время с 2019 года НЕ поддерживается Edge!) - демонстрация того, как использовать это для хороших параметров по умолчанию независимо от порядка:

function test(options) {
    var options = {
       // defaults
       url: 'defaultURL',
       some: 'somethingDefault',
       // override with input options
       ...options
    };
    
    var body = document.getElementsByTagName('body')[0];
    body.innerHTML += '<br>' + options.url + ' : ' + options.some;
}
test();
test({});
test({url:'myURL'});
test({some:'somethingOfMine'});
test({url:'overrideURL', some:'andSomething'});
test({url:'overrideURL', some:'andSomething', extra:'noProblem'});

Ссылка MDN: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Spread_syntax

... тем временем, что Edge поддерживает Object.assign () (IE не поддерживает, но я очень надеюсь, что мы сможем оставить IE позади :))

Аналогичным образом вы можете сделать

    function test(options) {
        var options = Object.assign({
           // defaults
           url: 'defaultURL',
           some: 'somethingDefault',
        }, options); // override with input options
        
        var body = document.getElementsByTagName('body')[0];
        body.innerHTML += '<br>' + options.url + ' : ' + options.some;
    }
    test();
    test({});
    test({url:'myURL'});
    test({some:'somethingOfMine'});
    test({url:'overrideURL', some:'andSomething'});
    test({url:'overrideURL', some:'andSomething', extra:'noProblem'});

РЕДАКТИРОВАТЬ: Из-за комментариев относительно параметров const проблема с использованием постоянных параметров в остальной части функции на самом деле , а не , что вы не можете этого сделать, это просто вы не можете использовать постоянную переменную в ее собственном объявлении - вам придется настроить входное имя на что-то вроде

function test(input_options){
   const options = {
     // defaults
     someKey:    'someDefaultValue',
     anotherKey: 'anotherDefaultValue',

     // merge-in input options
     ...input_options
   };

   // from now on use options with no problem
}

Ответ - да. Фактически, есть много языков, которые поддерживают параметры по умолчанию. Python - один из них:

def(a, enter="Hello"):
   print(a+enter)

Несмотря на то, что это код Python 3 из-за скобок, параметры по умолчанию в функциях также работают в JS.

Например, а в вашем случае:

function read_file(file, deleteAfter=false){
  console.log(deleteAfter);
}

read_file("test.txt");

Но иногда параметры по умолчанию действительно не нужны.

Вы можете просто определить переменную сразу после запуска функции, например:

function read_file(file){
  var deleteAfter = false;
  console.log(deleteAfter);
}

read_file("test.txt");

В обоих моих примерах он возвращает одно и то же. Но иногда они действительно могут быть полезны, например, в очень продвинутых проектах.

Итак, в заключение, в JS можно использовать значения параметров по умолчанию. Но это почти то же самое, что определение переменной сразу после запуска функции. Однако иногда они все же очень полезны. Как вы могли заметить, значения параметров по умолчанию занимают на 1 строку кода меньше, чем стандартный способ определения параметра сразу после запуска функции.

EDIT: И это очень важно! Это не будет работать в IE. См. документацию. Таким образом, с IE вы должны использовать метод «определить переменную в верхней части функции». Параметры по умолчанию не будут работать в IE.

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

const defaultConfig = {
 category: 'Animals',
 legs: 4
};

function checkOrganism(props) {
 const category = props.category || defaultConfig.category;
 const legs = props.legs || defaultConfig.legs;
}

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

Да, использование параметров по умолчанию полностью поддерживается в ES6 :

function read_file(file, delete_after = false) {
  // Code
}

или

const read_file = (file, delete_after = false) => {
    // Code
}

, но ранее в ES5 вы могли легко сделать это:

function read_file(file, delete_after) {
  var df = delete_after || false;
  // Code
}

Это означает, что если значение есть, используйте значение, в противном случае используйте второе значение после операции ||, которая делает то же самое ...

Примечание: также есть большая разница между ними, если вы передадите значение в ES6 , даже если значение будет ложным, оно будет заменено новым значением, например null или "" ... но ES5 один будет заменен только в том случае, если только переданное значение истинно, потому что способ || работает ...

Если по какой-то причине вы не на ES6, а - это с использованием параметров lodash по умолчанию, здесь используется функция по умолчанию _.defaultTo> метод:

var fn = function(a, b) {
  a = _.defaultTo(a, 'Hi')
  b = _.defaultTo(b, 'Mom!')

  console.log(a, b)
}

fn()                 // Hi Mom!
fn(undefined, null)  // Hi Mom!
fn(NaN, NaN)         // Hi Mom!
fn(1)                // 1 "Mom!"
fn(null, 2)          // Hi 2
fn(false, false)     // false false
fn(0, 2)             // 0 2

<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.11/lodash.min.js"></script>

Что установит значение по умолчанию, если текущее значение равно NaN , null или не определено <63819729907

Да, это параметр по умолчанию

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

Синтаксис:

function [name]([param1[ = defaultValue1 ][, ...  paramN[ = defaultValueN ]]]) {
   statements
}

Описание :

Параметры функций по умолчанию не определены. Однако в некоторых ситуациях может быть полезно установить другое значение по умолчанию. Здесь могут помочь параметры по умолчанию.

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

С параметрами по умолчанию в ES2015 проверка в теле функции больше не требуется. Теперь вы можете просто указать значение по умолчанию в заголовке функции.

Пример различий:

// OLD METHOD
function multiply(a, b) {
  b = (typeof b !== 'undefined') ?  b : 1;
  return a * b;
}

multiply(5, 2); // 10
multiply(5, 1); // 5
multiply(5);    // 5


// NEW METHOD
function multiply(a, b = 1) {
  return a * b;
}

multiply(5, 2); // 10
multiply(5, 1); // 5
multiply(5);    // 5

Примеры другого синтаксиса:

Заполнение не определено по сравнению с другими ложными значениями:

Даже если значение установлено явно при вызове, значение аргумента num является значением по умолчанию.

function test(num = 1) {
  console.log(typeof num);
}

test();          // 'number' (num is set to 1)
test(undefined); // 'number' (num is set to 1 too)

// test with other falsy values:
test('');        // 'string' (num is set to '')
test(null);      // 'object' (num is set to null)

Оценивается во время звонка:

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

function append(value, array = []) {
  array.push(value);
  return array;
}

append(1); //[1]
append(2); //[2], not [1, 2]


// This even applies to functions and variables
function callSomething(thing = something()) {
 return thing;
}

function something() {
  return 'sth';
}

callSomething();  //sth

Параметры по умолчанию доступны для последующих параметров по умолчанию:

Уже обнаруженные параметры доступны для более поздних параметров по умолчанию

function singularAutoPlural(singular, plural = singular + 's',
                        rallyingCry = plural + ' ATTACK!!!') {
  return [singular, plural, rallyingCry];
}

//["Gecko","Geckos", "Geckos ATTACK!!!"]
singularAutoPlural('Gecko');

//["Fox","Foxes", "Foxes ATTACK!!!"]
singularAutoPlural('Fox', 'Foxes');

//["Deer", "Deer", "Deer ... change."]
singularAutoPlural('Deer', 'Deer', 'Deer peaceably and respectfully \ petition the government for positive change.')

Функции, определенные внутри тела функции:

Представлено в Gecko 33 (Firefox 33 / Thunderbird 33 / SeaMonkey 2.30). На функции, объявленные в теле функции, нельзя ссылаться внутри параметров по умолчанию и вызывать ошибку ReferenceError (в настоящее время это ошибка TypeError в SpiderMonkey, см. Ошибку 1022967). Параметры по умолчанию всегда выполняются первыми, объявления функций внутри тела функции оцениваются позже.

// Doesn't work! Throws ReferenceError.
function f(a = go()) {
  function go() { return ':P'; }
}

Параметры без значений по умолчанию после параметров по умолчанию:

До Gecko 26 (Firefox 26 / Thunderbird 26 / SeaMonkey 2.23 / Firefox OS 1.2) следующий код приводил к ошибке SyntaxError. Это было исправлено в ошибке 777060 и работает должным образом в более поздних версиях. Параметры по-прежнему устанавливаются слева направо, перезаписывая параметры по умолчанию, даже если есть более поздние параметры без значений по умолчанию.

function f(x = 1, y) {
  return [x, y];
}

f(); // [1, undefined]
f(2); // [2, undefined]

Уничтоженный параметр с присвоением значения по умолчанию:

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

function f([x, y] = [1, 2], {z: z} = {z: 3}) {
  return x + y + z;
}

f(); // 6

def read_file(file, delete_after = false)
  # code
end

Следующий код может работать в этой ситуации, включая ECMAScript 6 (ES6), а также более ранние версии.

function read_file(file, delete_after) {
    if(delete_after == undefined)
        delete_after = false;//default value

    console.log('delete_after =',delete_after);
}
read_file('text1.txt',true);
read_file('text2.txt');

в качестве значения по умолчанию на языках работает, когда значение параметра функции пропускается при вызове, в JavaScript ему присваивается значение undefined . Этот подход не выглядит привлекательным программно, но имеет обратную совместимость .

ES6: Как уже упоминалось в большинстве ответов, в ES6 вы можете просто инициализировать параметр вместе со значением.

ES5: Большинство приведенных ответов недостаточно для меня, потому что бывают случаи, когда мне, возможно, придется передать ложные значения, такие как 0, null и undefined в a функция. Чтобы определить, является ли параметр неопределенным, потому что это значение, которое я передал вместо неопределенного из-за того, что он вообще не был определен, я делаю следующее:

function foo (param1, param2) {
   param1 = arguments.length >= 1 ? param1 : "default1";
   param2 = arguments.length >= 2 ? param2 : "default2";
}

Если вы используете ES6+, вы можете установить параметры по умолчанию следующим образом:

function test (foo = 1, bar = 2) {
  console.log(foo, bar);
}

test(5); // foo gets overwritten, bar remains default parameter

Если вам нужен синтаксис ES5, вы можете сделать это следующим образом:

function test(foo, bar) {
  foo = foo || 2;
  bar = bar || 0;
  
  console.log(foo, bar);
}

test(5); // foo gets overwritten, bar remains default parameter

В приведенном выше синтаксисе используется оператор OR. Оператор OR всегда возвращает первое значение, если его можно преобразовать в true, если нет, он возвращает значение правой стороны. Когда функция вызывается без соответствующего аргумента, JS-движок устанавливает переменную параметра (bar в нашем примере) на undefined. undefined Затем преобразуется в false, и поэтому оператор OR возвращает значение 0.

Используйте это, если вы хотите использовать последний синтаксис ECMA6 :

function myFunction(someValue = "This is DEFAULT!") {
  console.log("someValue --> ", someValue);
}

myFunction("Not A default value") // calling the function without default value
myFunction()  // calling the function with default value

Он называется default function parameters. Он позволяет инициализировать формальные параметры значениями по умолчанию, если значение не передано или не определено. ПРИМЕЧАНИЕ : Он не будет работать с Internet Explorer или более старыми браузерами.

Для максимально возможной совместимости используйте это:

function myFunction(someValue) {
  someValue = (someValue === undefined) ? "This is DEFAULT!" : someValue;
  console.log("someValue --> ", someValue);
}

myFunction("Not A default value") // calling the function without default value
myFunction()  // calling the function with default value

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

function throwIfNoValue() {
throw new Error('Missing argument');
}
function foo(argValue = throwIfNoValue()) {
return argValue ;
}

Здесь foo () - это функция, имеющая параметр с именем argValue. Если мы не передадим здесь ничего в вызове функции, то будет вызвана функция throwIfNoValue (), и возвращенный результат будет присвоен единственному аргументу argValue. Вот так вызов функции можно использовать в качестве параметра по умолчанию. Это делает код более простым и читаемым.

Этот пример взят отсюда

function helloWorld(name, symbol = '!!!') {
    name = name || 'worlds';
    console.log('hello ' + name + symbol);
}

helloWorld(); // hello worlds!!!

helloWorld('john'); // hello john!!!

helloWorld('john', '(>.<)'); // hello john(>.<)

helloWorld('john', undefined); // hello john!!!

helloWorld(undefined, undefined); // hello worlds!!!

Я настоятельно рекомендую соблюдать крайнюю осторожность при использовании значений параметров по умолчанию в javascript. Он часто создает ошибки при использовании вместе с функциями более высокого порядка, такими как forEach, map и reduce. Например, рассмотрим эту строку кода:

['1', '2', '3'].map(parseInt); // [1, NaN, NaN]

parseInt имеет необязательный второй параметр function parseInt(s, [radix =10]), но вызовы карты parseInt с тремя аргументами: ( элемент <2164427571> и <2164427571> элемент <2164427571> и <21644275250> массив ).

// unsafe
function read_file(fileName, deleteAfter=false) {
    if (deleteAfter) {
        console.log(`Reading and then deleting ${fileName}`);
    } else {
        console.log(`Just reading ${fileName}`);
    }
}

// better
function readFile(fileName, options) {
  const deleteAfter = !!(options && options.deleteAfter === true);
  read_file(fileName, deleteAfter);
}

console.log('unsafe...');
['log1.txt', 'log2.txt', 'log3.txt'].map(read_file);

console.log('better...');
['log1.txt', 'log2.txt', 'log3.txt'].map(readFile);

Согласно синтаксису

function [name]([param1[ = defaultValue1 ][, ...  paramN[ = defaultValueN ]]]) {
   statements
}

вы можете определить значение формальных параметров по умолчанию. а также проверьте неопределенное значение с помощью функции typeof .

Значения параметров по умолчанию

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

function foo(x,y) {
 x = x || 11;
 y = y || 31;
 console.log( x + y );
}
foo(); // 42
foo( 5, 6 ); // 11
foo( 5 ); // 36
foo( null, 6 ); // 17

Этот шаблон используется чаще всего, но он опасен, когда мы передаем такие значения, как

foo(0, 42)
foo( 0, 42 ); // 53 <-- Oops, not 42

Почему? Поскольку 0 is falsy и, следовательно, x || 11 results in 11, а не непосредственно передаются в 0. Чтобы исправить эту ошибку, некоторые люди вместо этого будут писать чек более подробно, например:

function foo(x,y) {
 x = (x !== undefined) ? x : 11;
 y = (y !== undefined) ? y : 31;
 console.log( x + y );
}
foo( 0, 42 ); // 42
foo( undefined, 6 ); // 17

Теперь мы можем изучить хороший полезный синтаксис, добавленный в ES6, чтобы упростить присвоение значений по умолчанию отсутствующим аргументам:

function foo(x = 11, y = 31) {
 console.log( x + y );
}

foo(); // 42
foo( 5, 6 ); // 11
foo( 0, 42 ); // 42
foo( 5 ); // 36
foo( 5, undefined ); // 36 <-- `undefined` is missing
foo( 5, null ); // 5 <-- null coerces to `0`
foo( undefined, 6 ); // 17 <-- `undefined` is missing
foo( null, 6 ); // 6 <-- null coerces to `0`

x = 11 в объявлении функции больше похоже на x !== undefined ? x : 11, чем на гораздо более распространенную идиому x || 11

Выражения значений по умолчанию

Function значения по умолчанию могут быть не просто простыми значениями, например 31; они могут быть любым допустимым выражением, даже function call:

function bar(val) {
 console.log( "bar called!" );
 return y + val;
}
function foo(x = y + 3, z = bar( x )) {
 console.log( x, z );
}
var y = 5;
foo(); // "bar called"
 // 8 13
foo( 10 ); // "bar called"
 // 10 15
y = 6;
foo( undefined, 10 ); // 9 10

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

Выражение значения по умолчанию может даже быть встроенным вызовом выражения функции - обычно называемым выражением немедленно вызываемой функции (IIFE):

function foo( x =
 (function(v){ return v + 11; })( 31 )
) {
 console.log( x );
}
foo(); // 42

Всем, кто заинтересован в том, чтобы код работал в Microsoft Edge, не используйте значения по умолчанию в параметрах функций.

function read_file(file, delete_after = false) {
    #code
}

В этом примере Edge выдаст ошибку «Ожидается ')'»

Чтобы обойти это, используйте

function read_file(file, delete_after) {
  if(delete_after == undefined)
  {
    delete_after = false;
  }
  #code
}

По состоянию на 8 августа 2016 г. проблема все еще сохраняется

Да, это будет работать в Javascript. Вы также можете сделать это:

function func(a=10,b=20)
{
    alert (a+' and '+b);
}

func(); // Result: 10 and 20

func(12); // Result: 12 and 20

func(22,25); // Result: 22 and 25

будучи давним разработчиком C ++ (новичок в веб-разработке :)), когда я впервые столкнулся с этой ситуацией, я выполнил назначение параметров в определении функции, как это упоминается в вопросе, следующим образом.

function myfunc(a,b=10)

Но учтите, что в разных браузерах это не работает единообразно. Для меня он работал с Chrome на моем рабочем столе, но не работал с Chrome на Android. Более безопасный вариант, как многие уже упоминали выше, -

    function myfunc(a,b)
    {
    if (typeof(b)==='undefined') b = 10;
......
    }

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

это решение работает для меня в js:

function read_file(file, delete_after) {
    delete_after = delete_after || false;
    // Code
}

Просто используйте явное сравнение с undefined.

function read_file(file, delete_after)
{
    if(delete_after === undefined) { delete_after = false; }
}

В качестве обновления ... с ECMAScript 6 вы можете НАКОНЕЦ установить значения по умолчанию в объявлениях параметров функции, например:

function f (x, y = 7, z = 42) {
  return x + y + z
}

f(1) === 50

На основании ссылки - http://es6-features.org/#DefaultParameterValues

В ECMAScript 6 вы действительно сможете написать именно то, что у вас есть:

function read_file(file, delete_after = false) {
  // Code
}

Это установит для delete_after значение false, если оно отсутствует, или undefined. Сегодня вы можете использовать такие функции ES6 с транспиляторами, как Babel.

Дополнительную информацию см. В статье MDN.

Я считаю, что что-то простое, подобное этому, гораздо более краткое и удобочитаемое лично.

function pick(arg, def) {
   return (typeof arg == 'undefined' ? def : arg);
}

function myFunc(x) {
  x = pick(x, 'my default');
} 

function read_file(file, delete_after) {
    delete_after = delete_after || "my default here";
    //rest of code
}

Присваивает delete_after значение delete_after, если это не значение falsey , в противном случае присваивается строка "my default here". Для получения дополнительных сведений ознакомьтесь с обзором языка Дуга Крокфорда и ознакомьтесь с разделом «Операторы».

Этот подход не работает, если вы хотите передать значение falsey , т.е. false, null, undefined, <2493446517> или <24189344 Если вам требуется передать значения falsey , вам нужно будет использовать метод из ответа Тома Риттера.

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

function read_file(values) {
    values = merge({ 
        delete_after : "my default here"
    }, values || {});

    // rest of code
}

// simple implementation based on $.extend() from jQuery
function merge() {
    var obj, name, copy,
        target = arguments[0] || {},
        i = 1,
        length = arguments.length;

    for (; i < length; i++) {
        if ((obj = arguments[i]) != null) {
            for (name in obj) {
                copy = obj[name];

                if (target === copy) {
                    continue;
                }
                else if (copy !== undefined) {
                    target[name] = copy;
                }
            }
        }
    }

    return target;
};

использовать

// will use the default delete_after value
read_file({ file: "my file" }); 

// will override default delete_after value
read_file({ file: "my file", delete_after: "my value" });