ES6 import "module" don't give acces to function of "module"

Question

I am trying to use ES6 imorts with babel and Node.js

import "./utils.js";

log("something"); //throw an error : log is not defined

My utils.js look like this :

function log(... params){
    console.log(... params);
}

log("module utils executed");
//Is executed and display "module utils executed" in the console.

I have also tryed to use export function log(... params) and export default log(... params) but it doesn't works.

So I don't understand how this is suppose to works...

EDIT:

I know that an other way to import is to do import utils from "./utils.js"

But it's not what I want. I want to be able to use log() without prefixing it with the module variable name. Like in this blog post

Answer 1

there Different ES6 import and Node.js require Question Describe The Difference

In case you will use Node.js require:

your utils.js File will be

function log(params) {
    console.log(params);
}

module.exports = {
   log
};

The other File will import your Utils Module will be

var utils = require('./utils');
utils.log("test");

In case you will use ES6 Modules:

your utils.js File will be

var log = function (params) {
    console.log(params);
}

var utils = {
    log: log
}

export default utils;

The other File will import your Utils Module will be

import utils from 'utils';

utils.log("test");

UPDATE

According to your Comment, Yes you can do this But using ES6 Module

your utils.js File will be

function log(params) {
    console.log(params);
}

function anotherLog(params) {
    console.log(params);
}

export { log, anotherLog }

The other File will import your Utils Module will be

import { log } from 'utils';

log("test");

Answer 2

No, there is no way to import all exported members of a module into the current namespace. Importing a module for side effects (i.e. import 'utils') does nothing with the members of utils.

The closest you can get is something like this:

utils.js

export function log(...params) { ... }
export function foo(a) { ... }

main.js

import * as u from './utils';
u.log(1, 2, 3);
u.foo(4);

or

import { log, foo } from './utils';
log(1, 2, 3);
foo(4);

One of the design goals of the ES6 module spec is a static module structure, which allows resolution of imports at compile time (before executing anything). Allowing blanket imports would make static analysis more difficult.

---

EDIT (do not do this!)

As @Bergi pointed out in the comments, you can add functions to the global namespace as follows:

utils.js

function log(...params) { ... }
global.log = log;

main.js

import './utils';  // import for side effects, add properties to the global object
log(1, 2, 3);      // the global object is in the scope chain, so this is resolved

However this is a bad idea. Global variables are slow to resolve and in general break the modularity you try to achieve by using modules in the first place.