一行区别:

       let fruits = ['orange','apple','banana']

from:从数组中逐个生成项。例如

    from(fruits).subscribe(console.log) // 'orange','apple','banana'

of:一次性释放整个数组。例如

 of(fruits).subscribe(console.log) //  ['orange','apple','banana']

注:of运算符可以表现为from运算符与展开运算符

 of(...fruits).subscribe(console.log) //  'orange','apple','banana'

从操作员可以接受其中之一

承诺 可迭代的 数组 可观测的

From从可观察对象中发出每个单独的项，也可以进行转换。

Of操作符接收原始值并从可观察对象中发出该值。

import {from, Observable, of} from 'rxjs';

const ofObs = of([1,2,3]);
const fromObs = from([2,3,4]);

const basicObs = Observable.create(observer=>{
    observer.next(100);
    observer.next(200);
    observer.next(300);
})
const promise = new Promise((resolve,reject)=>{
    resolve(100);
})

const array = [1,2,3];
const iterbale  = "Dhana";

// const myObs = from(ofObs);//possible and can emit individual item value everytime 1, then ,2 , then 3
// const myObs = from(fromObs);//possbile and can emit individual item value everytime 1, then ,2 , then 3
// const myObs = from(basicObs);//possbile and can emit individual item value everytime 100, then ,200 , then 300
const myObs = from(promise);//possible can emit value 100
// const myObs = array(promise);//possible and can emit individual item value everytime 1, then ,2 , then 3
// const myObs = iterable(promise);//possible and can emit individual item value everytime D then h then a then n then a


myObs.subscribe(d=>console.log(d))

import {from, of} from 'rxjs';

const basicOf1 = of([1,2,3,4,5,6]) // emits entire array of events
const basicfrom1 = from([1,2,3,4,5,6]) //emits each event at a time

const basicOf2 = of(1,2,3,4,5,6) // emits each event at a time
// const basicfrom2 = from(1,2,3,4,5,6) //throws error
//Uncaught TypeError: number is not observable

const basicOf3 = of(...[1,2,3,4,5,6]) // emits each event at a time
const basicfrom3 = from(...[1,2,3,4,5,6]) //throws error
//Uncaught TypeError: number is not observable
basicOf3.subscribe(d=>console.log(d))

这里是codeen的链接

在传递一个类数组结构(包括字符串)时，注意of和from之间的区别是很重要的:

Observable.of([1, 2, 3]).subscribe(x => console.log(x));

会立刻打印出整个数组。

另一方面，

Observable.from([1, 2, 3]).subscribe(x => console.log(x));

逐个打印元素。

对于字符串，行为是相同的，但在字符级别。

一行区别:

       let fruits = ['orange','apple','banana']

from:从数组中逐个生成项。例如

    from(fruits).subscribe(console.log) // 'orange','apple','banana'

of:一次性释放整个数组。例如

 of(fruits).subscribe(console.log) //  ['orange','apple','banana']

注:of运算符可以表现为from运算符与展开运算符

 of(...fruits).subscribe(console.log) //  'orange','apple','banana'

当我想到与.call / .apply方法的类比时，我发现更容易记住它们的区别。

你可以这样想:

通常，单独传递的所有参数(用逗号分隔)也会按照传递的顺序单独发出。Of()只是逐个发出所有参数(就像.call方法将参数传递给被调用的函数一样) 从某种意义上说，From()类似于.apply，它可以接受一个值数组作为参数，并将数组元素转换为用逗号分隔的独立参数。

因此，如果您有一个数组，并希望每个元素分别发出，您可以使用from()或通过使用of()和扩展操作符(如of(…arr))来获得相同的行为。

这有点复杂(从也可以观察到)，但通过这个类比，可能会更容易记住主要的区别。

from操作符获取事件源。从(源)

let array = [1,2,3,4,5]
from(array); //where array is source of events, array[of events]


let promise = new Promise(function(resolve, reject) {
  // executor (the producing code, "singer")
});
from(promise); //where promise is source of event, promise(of event)





let observable = Observable.create(function(observer) {
  observer.next(1);
  observer.next(2);
  observer.next(3);
  observer.next(4);
  observer.next(5);
  observer.complete();
});
from(observable); // where obsservable is source of events. 

运算符of接受单个事件。(event1, event2, event3)

of(1,2,3,4,5); // where 1,2,3,4,5 are individual events