Since `nameof` does not actually evaluate anything, the following would be
legal:
```
const x = nameof y; // "y"
const y = 1;
```
However, the shorthand property name workaround is not legal due to TDZ:
```
const x = Object.keys({y})[0]; // error due to TDZ
const y = 1;
```
With the shortand property name workaround you also run into the added runtime
overhead of:
* Constructing an object (`{y}`)
* Looking up a property (`Object.keys`)
* Calling a function (`Object.keys`)
* Allocating an array
* Indexing into the array
Whereas `nameof` has *no* runtime overhead, because it would be handled during
static semantics.
From: es-discuss <es-discuss-boun...@mozilla.org> On Behalf Of guest271314
Sent: Friday, June 14, 2019 11:17 AM
To: Stas Berkov <stas.ber...@gmail.com>
Cc: es-discuss@mozilla.org
Subject: Re: Re: What do you think about a C# 6 like nameof() expression for
Terms such as "more robust", "Less fragile." , "Less mess." are subjective.
"Fragile" how? What is meant by "mess"?
If the proposal is that ```nameof``` is briefer than using shorthand property
names or computed property names to get an identifier as a string, then
```nameof``` would be less code.
> You can rename field/property without fear you break something (using IDE
> refactoring tools).
The use case appears to be within the context of an IDE?
For users that roll their own code by hand at a text editor and do not use an
IDE for composing code (or relying on an IDE for logging errors), am not able
to discern how ```nameof``` is different than using
```Object.getOwnPropertyDescriptors(other).name.value``` or
```Object.keys({userName})[0]```. The actual code will need to be tested in
different browsers anyway before deployment to get the actual results.
If a user has decided they _have_ to use some form of a dynamic "IDE" to
compose code and log errors - while they are writing the code, they can open
DevTools at Chromium or Chrome then select ```Sources``` => ```Snippets``` =>
```New snippet```, where
```
const n = 123;
const n = 456;
```
will highlight the line where the error occurs - during writing the code - the
as a red circle with a transparent "x" in the middle
```Uncaught SyntaxError: Identifier 'n' has already been declared````
To run the code press ```ctrl+enter```.
On Fri, Jun 14, 2019 at 5:48 PM Stas Berkov
<stas.ber...@gmail.com<mailto:stas.ber...@gmail.com>> wrote:
Less fragile. Less mess. You can rename field/property without fear you break
something (using IDE refactoring tools).
With high probablity you will break something when you refactor and have fields
hardcoded as strings.
Someone can object that you can rename strings as well.
Issue here that you can ocassionally change non-related strings that should not
be changed even they match or have matching substring.
On Fri, Jun 14, 2019 at 9:38 PM guest271314
<guest271...@gmail.com<mailto:guest271...@gmail.com>> wrote:
Is Case 1 equivalent to a briefer version of
```
if (userName == undefined) {
throw new Error(`Argument cannot be null:
${Object.keys({userName})[0]}`);
}
```
?
If not, how is ```nameof``` different?
What is the difference between the use of
```message.hasOwnProperty(property)``` and ```nameof msg.expiration_utc_time```?
> You get more robust code.
How is "robust" objectively determined?
On Fri, Jun 14, 2019 at 5:21 PM Stas Berkov
<stas.ber...@gmail.com<mailto:stas.ber...@gmail.com>> wrote:
ES can befit from `nameof` feature the same way as TS. There is no TS specific
in it.
It was ask to introduce in TS as a workaround since TS is considered as
extention of ES.
Case 1. Function guard.
```
function func1(param1, param2, param3, userName, param4, param5) {
if (userName == undefined) {
throw new ArgumentNullError(nameof userName); // `ArgumentNullError` is
a custom error, derived from `Error`, composes error message like "Argument
cannot be null: userName".
}
}
```
Case 2. Access extended information an object property.
Assume a function
```
function protoPropertyIsSet(message, property) {
return message != null && message.hasOwnProperty(property);
}
```
Then in code you use it as `if (protoPropertyIsSet(msg, "expiration_utc_time"))
{... }`.
Having `nameof` would allow you to do that `if (protoPropertyIsSet(msg, nameof
msg.expiration_utc_time)) {... }`.
You get more robust code.
On Fri, Jun 14, 2019 at 5:46 PM Augusto Moura
<augusto.borg...@gmail.com<mailto:augusto.borg...@gmail.com>> wrote:
Can you list the benefits of having this operators? Maybe with example use cases
If I understand it correctly, the operator fits better in compiled
(and typed) languages, most of the use cases don't apply to dynamic
Javascript
The only legit use case I can think of is helping refactor tools to
rename properties (but even mismatch errors between strings and
properties names can be caught in compile time using modern
Typescript)
Em sex, 14 de jun de 2019 às 10:05, Stas Berkov
<stas.ber...@gmail.com<mailto:stas.ber...@gmail.com>> escreveu:
>
> Can we revisit this issue?
>
>
> In C# there is `nameof`, in Swift you can do the same by calling
>
> ```
>
> let keyPath = \Person.mother.firstName
>
> NSPredicate(format: "%K == %@", keyPath, "Andrew")
>
> ```
>
> Let's introduce `nameof` in ES, please.
>
>
> Devs from TypeScript don't want to introduce this feature in TypeScript
> unless it is available in ES (
> https://github.com/microsoft/TypeScript/issues/1579<https://nam06.safelinks.protection.outlook.com/?url=https%3A%2F%2Fgithub.com%2Fmicrosoft%2FTypeScript%2Fissues%2F1579&data=02%7C01%7Cron.buckton%40microsoft.com%7C9b2c54f48f5d4505fb1008d6f0f494c9%7C72f988bf86f141af91ab2d7cd011db47%7C1%7C0%7C636961330684601102&sdata=P7VAkHGEM1WeVpzpovf9TxXOdkzcuQgcBsoGwMNqmuA%3D&reserved=0>
> )
>
> This feature is eagarly being asked by TypeScript community.
>
>
> I understand there are couple issues related to `nameof` feature in ES. They
> are: minification and what to do if user already has `nameof` function.
>
>
> Minification.
>
> 1. If your code to be minimized be prepared that variable names will also
> change.
>
> 2. (just a possibility) Minimizer can have option to replace
> `nameof(someVar)` with result of `nameof` function.
>
>
>
> What if user already has `nameof` function.
>
> 1. To maintain status quo we can user `nameof` function having priority over
> newly introduced language feature.
>
> 2. OR we can use `typeof` syntax, e.g. `nameof msg.userName` (// returns
> "userName" string)
>
> _______________________________________________
> es-discuss mailing list
> es-discuss@mozilla.org<mailto:es-discuss@mozilla.org>
> https://mail.mozilla.org/listinfo/es-discuss<https://nam06.safelinks.protection.outlook.com/?url=https%3A%2F%2Fmail.mozilla.org%2Flistinfo%2Fes-discuss&data=02%7C01%7Cron.buckton%40microsoft.com%7C9b2c54f48f5d4505fb1008d6f0f494c9%7C72f988bf86f141af91ab2d7cd011db47%7C1%7C0%7C636961330684611108&sdata=hyL72vBqg5ecV6O%2BO33sWVN%2BQ2SOqeFyHGGKSw%2BH5fk%3D&reserved=0>
--
Atenciosamente,
Augusto Borges de Moura
_______________________________________________
es-discuss mailing list
es-discuss@mozilla.org<mailto:es-discuss@mozilla.org>
https://mail.mozilla.org/listinfo/es-discuss<https://nam06.safelinks.protection.outlook.com/?url=https%3A%2F%2Fmail.mozilla.org%2Flistinfo%2Fes-discuss&data=02%7C01%7Cron.buckton%40microsoft.com%7C9b2c54f48f5d4505fb1008d6f0f494c9%7C72f988bf86f141af91ab2d7cd011db47%7C1%7C0%7C636961330684611108&sdata=hyL72vBqg5ecV6O%2BO33sWVN%2BQ2SOqeFyHGGKSw%2BH5fk%3D&reserved=0>
_______________________________________________
es-discuss mailing list
es-discuss@mozilla.org
https://mail.mozilla.org/listinfo/es-discuss
