Асинхронность callback с return и throw
 

Подскажите пожалуйста минусы использования callback (помимо основных лапша в коде), и почему мы не можем использовать return и throw с callbackами (помимо основной причины, что callback может быть асинхронным и возвращать значение уже после присваивания этого асинхронного значения какой либо переменной).

На самом деле уже много придумано, как избавиться от callback

https://rxjs-dev.firebaseapp.com/

https://github.com/stoeffel/awesome-fp-js

http://2ality.com/2016/10/asynchronous-iteration.html

https://codeburst.io/functional-prog...t-e57e7e28c0e5

Вопрос не об этом)

callback сам по себе никакой лапши в коде не создает...

Куда возвращать?

Вопрос как раз об этом )

https://tproger.ru/translations/asyn...us-javascript/
В этой статье есть вот такая вот запись:
Проблемы с коллбэками:

- легко написать «callback hell» или спагетти-код, если не использовать их должным образом;
- легко упустить обработку ошибок;
- нельзя возвращать значения с выражением return, как и нельзя использовать ключевое слово throw.

Можете привести пожалуйста пример с третьим вариантом(про throw и return), не могу его понять.

проблемы высосаны из пальца, а это обычно происходит если на javascript программировать как на java )

// return
const foo = (function () {
  return {
    abc(callback) {
      var result = 'some'
      return callback(result)
    }
  }
})()

console.log(foo.abc(function (datResult) {
  return datResult
})) // some

// throw
const tthrow = new Promise(function (resolve, reject) {
  reject('act like throw')
}).then(function (message) {
  console.log('pure', message)
}).catch(function (error) {
  console.log('error', error)
}) // error act like throw

У вас в коде some возвращается в консоле, в итоге причина все равно не ясна, в каком коде нельзя применить return, throw)

let tthrow = new Promise(function (resolve, reject) {
  try {
    throw new Error('error via throw')
  } catch (error) {
    reject(error)
  }
}).then(function () {
}).catch(function (error) {
  console.log('error', typeof error, error)
})

что хочешь то?)))

Там описываются недостатки callback, а не достоинства promise)

function asyncCallDomainWithoutCallback() {
	let resultText;
	const xhr = new XMLHttpRequest();
	const url = 'http://bar.other/resources/public-data/';
  xhr.timeout = 30000;
  xhr.open('POST', url, true);
  xhr.send(); 
  xhr.onload = ()=>{resultText = xhr.responseText};
  return resultText;
}

function handler1(){
 const serverResponse = asyncCallDomainWithoutCallback(); 
 if(serverResponse) { // serverResponse = undefined
 	throw new Error('THROW будет упущен')
 }
return serverResponse;
}





function asyncCallDomainWitCallback(callbackForAsync) {
	const xhr = new XMLHttpRequest();
	const url = 'http://bar.other/resources/public-data/';
  xhr.timeout = 30000;
  xhr.open('POST', url, true);
  xhr.send(); 
  xhr.onload = ()=>{ callbackForAsync(xhr.responseText) };
}

function handler2(callbackForAsync){
	asyncCallDomainWitCallback(callbackForAsync);
}

function callback (resultText) {
  const serverResponse = asyncCallDomain(callback); 
 if(serverResponse) {
 	throw new Error('THROW будет упущен') // никто не получит ошибку
 }else{
 
 }
return serverResponse; // никто не получит возвращаемое значение
}

Вот код описывающий приведенное выше описание

function asyncCallDomainWithoutCallback() {
	let resultText;
	const xhr = new XMLHttpRequest();
	const url = 'http://bar.other/resources/public-data/';
  xhr.timeout = 30000;
  xhr.open('POST', url, true);
  xhr.send(); 
  xhr.onload = ()=>{resultText = xhr.responseText};
  return resultText;
}

function handler1(){
 const serverResponse = asyncCallDomainWithoutCallback(); 
 if(serverResponse) { // serverResponse = undefined
 	throw new Error('THROW будет упущен')
 }
return serverResponse;
}





function asyncCallDomainWitCallback(callbackForAsync) {
	const xhr = new XMLHttpRequest();
	const url = 'http://bar.other/resources/public-data/';
  xhr.timeout = 30000;
  xhr.open('POST', url, true);
  xhr.send(); 
  xhr.onload = ()=>{ callbackForAsync(xhr.responseText) };
}

function handler2(callbackForAsync){
	asyncCallDomainWitCallback(callbackForAsync);
}

function callback (resultText) {
  const serverResponse = asyncCallDomain(callback); 
 if(serverResponse) {
 	throw new Error('THROW будет упущен') // никто не получит ошибку
 }else{
 
 }
return serverResponse; // никто не получит возвращаемое значение
}

Вот код описывающий поведение callback.

эти(твои) примеры, в моем мозгу ))) выглядят так:

let a = 1
let b = 2
console.log(c + d)