Show HN: Write ajax requests with template literals(github.com)

10 pointsby zackifyvor 10 Jahren9 comments

Show HN: Write ajax requests with template literals

https://github.com/Legitcode/legible

9 comments

jacobwgvor 10 Jahren

I may be missing something, but how is this:

  let response = await request`
    url: https://api.myapp.com/register
    method: POST
    body: ${body}
    headers: ${{
      Authorization: 'Bearer: token'
    }}
  `

better than:

  let response = await request({
    url: 'https://api.myapp.com/register',
    method: 'POST',
    body: body,
    headers: {
      Authorization: 'Bearer: token'
    }
  )

Perhaps it's just personal style, but the readability of both is similar and it feels like you've created a subset of a JSON or YAML parser that isn't as bulletproof / flexible.

I did enjoy the example of how template literals are parsed under the hood.

zackifyvor 10 Jahren

I think the syntax is nicer if you take a look at the example of doing partial requests. I made this library for fun, but I'll be splitting out my requests into partials for an entire api. I think you get benefits from using the partials more so than your example. Either way, it was made just for fun :)

partial:

  const twitter = {
    register: partial`
      url: https://api.twitter.com/register,
      method: POST
    `
  }

  twitter.register`
    body: ${{
      email: '[email protected]',
      password: 'Tester'
    }}
  `

Without template literals:

  const twitter = {
    register: {
      url: 'https://api.myapp.com/register',
      method: 'POST',
    }
  }

  let response = await request({ 
    ...twitter.register,
    body: body,
  })

meh321vor 10 Jahren

The second example could be more concise IMHO:

    const twitter = {
      register: function(opts){
        return request({
          url: '...',
          method: 'POST',
          ...opts
        });
      }
    }
  
    const resp = await twitter.register({ body });

EDIT: made it even more concise! -- back to real work :/

zackifyvor 10 Jahren

Sure, keep adding many methods and make new functions every time. I totally get what you're saying. I just like the syntactic sugar of Template Literals :)

mrsharpobluntovor 10 Jahren

Plus you lose all the benefits of linters, type checkers, & even things like syntax highlighting.

drumvor 10 Jahren

I agree. Unfortunately I think this is only subjectively better to the author, provides less functionality than the example it compared itself too, and adds an extra dependency.

zackifyvor 10 Jahren

The only thing I disagree with is making an extra dependency sound like such a bad thing. Nobody uses fetch directly. You always wrap it into a more suitable api for your project. So either you're going to do that yourself, or add in a small library like this.

twfarlandvor 10 Jahren

Such mischief. Template literals make me feel very yucky. A totally unnecessary complication.

stephenhandleyvor 10 Jahren

yikes