## Other ### specMemberExpressionLiterals Transform keywords and reserved word properties in member expressions into string literals: ```javascript obj.default = ""; obj.throw = ""; obj.case = ""; obj.delete = ""; ``` to ```javascript obj["default"] = ""; obj["throw"] = ""; obj["case"] = ""; obj["delete"] = ""; ``` ### specPropertyLiterals Transforms keywords and reserved word property keys into string literals: ```javascript var obj = { default: "", throw: "", case: "", delete: "" }; ``` to ```javascript var obj = { "default": "", "throw": "", "case": "", "delete": "" }; ``` ### useStrict ES6 modules are strict mode by default, this is a restricted variant of JavaScript that enables more optimisations and better errors. See the MDN article [Strict mode](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Strict_mode) for more information.Disabled by default
These are only usable if you enable experimental support. See experimental usage for information.
## Playground - [memoizationOperator](/docs/usage/playground#memoization-assignment-operator) - [methodBinding](/docs/usage/playground#method-binding) - [objectGetterMemoization](/docs/usage/playground#object-getter-memoization)Not recommended
It's highly recommended not to disable this transformer.
### Other #### react ## Optional transformers 6to5 provides various optional transformers for those of you who want to take your code that extra mile. ```javascript require("6to5").transform("code", { optional: ["transformerName"] }); ``` ```sh 6to5 --optional transformerName ``` ### asyncToGenerator Transforms async functions to a generator that uses a helper. This is useful if you don't want to use `regenerator` or `bluebird`. ```javascript async function foo() { await bar(); } ``` to ```javascript var _asyncToGenerator = function (fn) { ... }; var foo = _asyncToGenerator(function* () { yield bar(); }); ``` ### bluebirdCoroutines Transforms async functions to their equivalent bluebird method. ```javascript async function foo() { await bar(); } ``` to ```javascript var Bluebird = require("bluebird"); var foo = Bluebird.coroutine(function* () { yield bar(); }); ``` ### coreAliasing 6to5 will uses various ES6 methods around your code such as `Array.from` and `Object.assign`. This usually means that the use of a global polluting polyfill is required, fortunately there's the `coreAliasing` transformer. This transformer transforms code such as ```javascript var arr = Array.from("foobar"); // ["f", "o", "o", "b", "a", "r"] ``` into ```javascript var core = require("core-js"); var arr = core.Array.from("foobar"); ``` Not only that but it can also transform iterator construction so ```javascript var iterator = "foobar"[Symbol.iterator](); iterator.next(); // { done: false, value: "f" } ``` becomes ```javascript var core = require("core-js"); var iterator = core.$for.getIterator("foobar"); ``` This means that you can use **every** single 6to5 feature without a globally polluting polyfill, minus [caveats](/docs/caveats) and all. This is fantastic for library authors as it means that you can write your libraries with 6to5 and utilise all ES6 methods and syntax without polluting your users global scope that may lead to collisions and nasty bugs.Disabled by default
These are only usable if you enable playground support. See playground usage for information.
### protoToAssign The `protoToAssign` optional transformer will transform all `__proto__` assignments to a method that will do a shallow copy of all properties. This means that the following **will** work: ```javascript var foo = { a: 1 }; var bar = { b: 2 }; bar.__proto__ = foo; bar.a; // 1 bar.b; // 2 ``` however the following **will not**: ```javascript var foo = { a: 1 }; var bar = { b: 2 }; bar.__proto__ = foo; bar.a; // 1 foo.a = 2; bar.a; // 1 - should be 2 but remember that nothing is bound and it's a straight copy ``` This is a case that you have to be aware of if you intend to use this transformer. ### typeofSymbol ES6 introduces a new native type called [symbols](/docs/tour#symbols). This transformer wraps all `typeof` expressions with a method that replicates native behaviour. (ie. returning "symbol" for symbols) ```javascript typeof Symbol() === "symbol"; ``` to ```javascript var _typeof = function (obj) { return obj && obj.constructor === Symbol ? "symbol" : typeof obj; }; _typeof(Symbol()) === "symbol"; ``` ### undefinedToVoid Some JavaScript implementations allow `undefined` to be overwritten, this may lead to peculiar bugs that are extremely hard to track down. This transformer transforms `undefined` into `void 0` which returns `undefined` regardless of if it's been reassigned. ```javascript foo === undefined; ``` to ```javascript foo === void 0; ```If you use this transformer then the package
core-jsis required. Runnpm install core-js --saveto add it to your current node/browserify project.