퓨즈[Fusetools] 문서[Docs] 번역

  1. Home
  2. 퓨즈[Fusetools] 문서[Docs] 번역
  3. 옵저버블[Observables]
  4. API 레퍼런스

API 레퍼런스

Observable API

Observable 값

observable이 하나의 값만 보유하고 있다면, .value 속성을 사용하여 그 값을 얻거나 설정할 수 있습니다:

1
2
3
var someString = Observable("foobar");
console.log(someString.value); // "foobar"를 출력합니다.
someString.value = "barfoo"; // 값을 설정하고 구독자에게 알립니다.

.value 속성이 설정되면 모든 등록자에게 통지됩니다.

빈 Observable은 .value === undefined 및 .length === 0입니다.

Observable 리스트

Observable을 값 목록(list of values)으로 사용하려면 .add(item) 및 .remove(item)과 같은 메서드를 사용하여 observable을 조작할 수 있습니다. .length 속성을 통해 목록의 값 수를 쿼리할 수도 있습니다.

1
2
3
4
5
var friends = Observable("Jake", "Jane", "Joe");
console.log(friends.length); // 3 출력

friends.add("Gina");
console.log(friends.length); // 4 출력

Observable 리스트로 가능한 것을 확인하려면 전체 멤버 리스트를 보십시오.

Observables가 있는 데이터 유형

Observable은 모든 기본 유형에 사용할 수 있습니다. 숫자(Number), 문자열(string), 부울(boolean) 및 벡터(vector) 유형이 포함됩니다. Number, string 및 boolean은 일반적인 JavaScript 리터럴을 사용하여 만듭니다:

1
2
3
var obsNumber = Observable(10.5);
var obsString = Observable("hello");
var obsBool = Observable(true);

벡터 유형(예: 색상)이 필요한 데이터 바인딩의 경우 자바스크립트 배열을 사용할 수 있습니다:

1
2
var obsRedColor = Observable([1,0,0,1]);
var obsWhiteAndBlack = Observable([1,1,1,1], [0,0,0,1]);

Observable 함수

Observable이 유일한 인수로 함수를 사용하여 초기화되면 Observable 함수의 .value는 함수를 평가하여 계산됩니다.

반응 종속성(Reactive dependencies)은 함수를 평가하는 동안 다른 모든 Observable이 접촉되면 자동으로 생성됩니다.

예제:

1
2
3
4
5
6
var firstName = Observable("John");
var lastName = Observable("Doe");

var fullName = Observable(function() {
    return firstName.value + " " + lastName.value;
})

firstName 또는 lastName이 변경되면 fullName이 자동으로 업데이트됩니다.

예, 마법같죠.

멤버들(Members)

value

Observable의 현재 값을 가져오거나 설정합니다.

value 속성은 getAt(0) 및 replaceAt(0)의 약자로 사용됩니다. 이것은 값이 하나인 Observable과 함께 사용되는 경우가 많지만, 필수 사항은 아닙니다.

1
2
3
4
if (isSomethingEnabled.value) {
    doSomething();
}
isSomethingEnabled.value = false;

toArray()

Observable 내부 값 배열의 단순 복사본을 반환합니다.

1
2
var obs = Observable(1,2,3);
var obsArray = obs.toArray(); //obsArray == [1,2,3]

연산자 리스트

add(value)

Observable 리스트에 값을 추가합니다.

1
2
var colors = Observable("Red", "Green");
colors.add("Blue");

addAll(items)

Observable 끝에 items 배열을 추가합니다.

1
2
3
4
5
var val = new Observable(1, 2, 3);

val.addAll([4, 5, 6]);

//val = Observable(1, 2, 3, 4, 5, 6);

clear()

Observable에서 모든 값을 제거합니다.

1
2
var colors = Observable("Red", "Green");
colors.clear();

contains(value)

var에 value가 있으면 true를 반환합니다.

1
2
Observable seasons = Observable("Summer", "Fall", "Winter", "Spring");
var winterExists = seasons.contains("Winter"); // true

forEach(func(item))

Observable의 모든 값에 대해 func을 호출합니다.

1
2
3
4
var numbers = Observable(10, 2, 50, 3);
numbers.forEach(function(number) {
    console.log(number + " is a nice number!");
});

forEach(func(item,index))

Observable의 모든 값에 대해 func을 호출합니다.

1
2
3
4
var numbers = Observable(10, 2, 50, 3);
numbers.forEach(function(number, index) {
    console.log(number + " has the index: " + index);
});

func이 두 개의 인수를 허용하면 두 번째 인수는 Observable에 있는 해당 아이템의 인덱스입니다.

getAt(index)

지정된 인덱스의 값을 돌려줍니다.

1
2
var seasons = Observable("Summer", "Fall", "Winter", "Spring");
console.log(seasons.getAt(2)); //output: "Winter"

identity()

식별 함수( map(function(x) { return x; }) )를 사용하여 map을 호출하는 것과 같습니다.

양방향 데이터 바인딩이 필요하지만 원본 Observable의 데이터를 훼손하고 싶지 않을 때 유용합니다.

1
2
var originalData = Observable("This is my original data");
var nonClobberedData = originalData.identity(); // 양방향 데이터 바인딩에 안전함

indexOf(value)

최초로 나타나는 value의 인덱스를 돌려줍니다.

1
2
var seasons = Observable("Summer", "Fall", "Winter", "Spring");
var index = seasons.indexOf("Winter"); // 2

insertAll(index, array)

배열의 내용을 지정된 인덱스에 삽입합니다.

1
2
3
4
var clouds = Observable("Cirrus", "Alto", "Stratus");
clouds.insertAll(1, ["Cumulus", "Mammatus"]);

//clouds = Observable("Cirrus", "Cumulus", "Mammatus", "Alto", "Stratus");

insertAt(index, value)

지정된 인덱스에 값을 삽입합니다.

1
2
3
4
var words = Observable("foo", "bar");
words.insertAt(1, "baz");

console.log(words); // Observable("foo", "baz", "bar")

.length

Observable 리스트의 갯수를 반환합니다.

1
2
var fruits = Observable("Orange", "Apple", "Pear");
console.log(fruits.length); // 출력: 3

refreshAll(newValues, compareFunc, updateFunc, mapFunc)

Observable의 모든 아이템을 newValues의 값으로 업데이트합니다. compareFunc는 두 항목이 같은지 여부를 확인하는 데 사용됩니다. updateFunc는 compareFunc에서 일치 항목을 찾으면 기존 항목을 새 값으로 업데이트하는 데 사용됩니다. mapFunc는 새 항목이 발견될 때마다 호출되어 새 항목에 매핑되도록 합니다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
var items = Observable(
    {id: 1, text: "one" },
    {id: 2, text: "two" },
    {id: 3, text: "tres" },
);

var newItems = [
    {id: 3, text: "three" },
    {id: 4, text: "four" },
    {id: 5, text: "five" }
];

items.refreshAll(newItems,
    //Compare on ID
    function(oldItem, newItem){
        return oldItem.id == newItem.id;
    },
    // Update text
    function(oldItem, newItem){
        oldItem.text.value = newItem.text;
    },
    // Map to object with an observable version of text
    function(newItem){
        return {
            id: newItem.id,
            text: Observable(newItem.text)
        };
    }
);

remove(value)

Observable 리스트에서 value의 첫 번째 항목을 제거합니다.

1
2
var shapes = Observable("Round", "Square", "Rectangular");
shapes.remove("Rectangular");

removeAt(index)

지정된 인덱스의 값을 삭제합니다.

1
2
var shapes = Observable("Round", "Square", "Rectangular");
shapes.removeAt(2);

removeRange(start, count)

start로부터 시작해서 count 만큼의 아이템을 삭제합니다.

1
2
3
var letters = Observable("a", "b", "c", "d");
letters.removeRange(1, 2);
//letters = Observable("a", "d");

removeWhere(func)

func가 true 인 모든 값을 제거합니다.

1
2
3
4
5
6
7
8
var hotPlaces = Observable(
    {name: "Oslo", temperature: 30},
    {name: "New York", temperature: 24},
    {name: "California", temperature: 27},
    {name: "Sydney", temperature: 10}
).removeWhere(function(place){
    return place.temperature < 20;
}); // 목록에서 Sydney 제거

replaceAll(array)

Observable 값을 배열의 값으로 바꿉니다.

1
2
var colors = Observable("Red", "Green", "Blue");
colors.replaceAll(["Orange", "Cyan", "Pink"]);

replaceAt(index, value)

index의 값을 value로 바꿉니다.

1
2
var ingredients = Observable("sugar", "milk", "potato");
ingredients.replaceAt(2, "flour"); // "potato"를 "flour"로 대체합니다.

tryRemove(value)

Observable 리스트에서 value에 해당하는 첫 번째 값을 제거하려고 시도합니다. 성공하면 true를 반환하고 그렇지 않으면 false를 반환합니다.

1
2
3
4
var shapes = Observable("Round", "Square", "Rectangular");
if(shapes.tryRemove("Rectangular")) {
    console.log("success");
}

반응 연산자(Reactive operators)

FuseJS는 다른 Observable에서 Observable을 반환하는 반응 연산자 집합을 제공됩니다. 즉, 원래 Observable이 변경되면 반응 연산자를 적용한 결과로 생성된 Observable도 자동으로 변경됩니다.

대부분의 연산자는 단방향입니다. 결과로 나오는 Observable을 변경하더라도 Observable 소스는 변경되지 않습니다(이 경우 결과로 생성되는 Observable을 수정하는 것은 실제로 오류입니다). ‘…TwoWay’ 함수는 양방향 바인딩을 만듭니다. 결과로 나오는 Observable 리스트의 변경은 소스를 Observable로 변경합니다.

많은 연산자는 값뿐만 아니라 객체를 사용하여 작업합니다. Observable 출력에서 ​​객체의 속성을 수정하면 동일한 객체이기 때문에 소스를 업데이트하는 중일 수 있습니다. 소스에 Observable 객체 목록이 포함되어 있을 수도 있습니다. 이 경우 변경 사항은 Observable에서 정상적으로 진행됩니다. 단방향/양방향은 조작자가 만든 높은 수준의 Observable 상태에서 변경된 방향만 참조합니다.

any(filter)

Observable가 호출된 관찰 가능 여부를 나타내는 boolean을 포함하는 새로운 Observable을 리턴합니다.

1
2
3
4
5
6
7
8
9
var vehicles = Observable(
    {type: "car", name: "SuperSpeeder 2000"},
    {type: "car", name: "Initial Dash 2k00"},
    {type: "boat", name: "Floaty McFloatface"}
);

var hasBoats = vehicles.any({type: "boat"}); //true
var hasAircraft = vehicles.any({type: "aircraft"}); //false
var hasCar = veichles.any(function(x) { return x.type === "car"; }) //true

combine([obs, …], func)

현재 observable 또는 ‘obs’ observable(통칭하여 “dependencies”)가 변경될 때마다 func을 호출합니다.

인수는 각 종속성의 현재 .value를 보유하며, 첫 번째 인수는 this.value이고, 순서대로 각 연속 Observable의 값이 따라옵니다.

1
2
3
4
5
6
7
8
9
10
11
var foo = Observable(1);
var boo = Observable(2);
var moo = Observable(3);

var res = foo.combine(boo, moo, function(f, b, m) {
    // f는 foo의 현재 .value를 유지합니다.
    // b는 boo의 현재 .value를 유지합니다.
    // m은 moo의 현재 .value를 유지합니다.

    return f+b+m; // 결과 관측 값은 6을 산출할 것입니다.
})

combine에 제공된 func이 값을 반환하면 그 값은 결과로 나오는 Observable 값의 .value를 대체합니다. 함수가 아무것도 반환하지 않으면(정의되지 않음) func는 func에서 this 매개 변수를 수정하여 결과로 생성되는 observable을 업데이트해야 합니다.

종속성마다 값을 사용할 수 없는 경우에도 모든 변경 사항에 대해 combine이 실행됩니다. 이를 방지하려면 combineLatest를 참조하십시오.

combine은 이들 중 일부가 배열인 경우에도 각 종속성의 첫 번째 값(.value)만 제공한다는 점에 유의하십시오. 각 종속성의 모든 값을 가져 오려면 .combineArrays를 참조하십시오.

combineLatest([obs, …], func)

combine과 동일하지만 모든 종속성에 대해 하나 이상의 값(.length> 0)을 사용할 수 있을 때까지 func를 실행하지 않습니다.

combineArrays([obs, …], func)

combine과 동일하지만 각 Observable의 첫 번째 값 대신 각 Observable의 모든 값을 갖는 각 종속성에 대한 배열을 제공합니다.

1
2
3
4
5
6
7
8
9
10
11
var foo = Observable(1);
var boo = Observable("a", "b", c);
var moo = Observable(3);

var res = foo.combineArrays(boo, moo, function(f, b, m) {
    // f holds [1]
    // b holds ["a", "b", "c"]
    // m holds [3]

    return [f[0], m[0], b.length]; // the resulting observable will hold the values (1, 3, 3)
})

combineArray에 제공된 func이 배열을 반환하면 배열의 요소가 결과로 생성되는 observable의 모든 요소를 대체합니다. 함수가 아무것도 반환하지 않으면(정의되지 않음) func는 func에서 this 매개 변수를 수정하여 결과로 생성되는 observable을 업데이트해야 합니다.

count()

Observable의 값 수를 Observable 숫자로 반환합니다. Observable에서 항목을 추가하거나 제거 할 때마다 갯수가 변경됩니다.

1
2
3
4
5
6
7
books = Observable(
    "UX and you",
    "Observing the observer",
    "Documenting the documenter"
);

numBooks = books.count(); //result: 3

count(condition)

condition이 함수이면 조건이 참인 Observable 값 수를 반환합니다. 조건이 객체이면 조건에 속성이 있는 값의 양을 포함하는 Observable 객체를 반환합니다.

1
2
3
4
5
6
7
8
9
var tasks = Observable(
    { title: "Learn Fuse", isDone: true },
    { title: "Learn about Observables", isDone: true },
    { title: "Make awesome app", isDone: false }
);
var tasksDone = tasks.count(function(x){
    return x.isDone;
}); // 2
var tasksDone = tasks.count({isDone: true}); //2

expand(func)

Observable에 단일 배열만 들어있으면 expand는 해당 배열의 값을 포함하는 Observable을 반환합니다.

Observable([1,2,3]).expand() -> Observable(1,2,3)

filter(condition)

지정된 조건을 통과하는 값만 전파하는 Observable 객체를 반환합니다. 그렇지 않으면 이전 값을 유지합니다.

이 방법은 Observable 아이템의 첫 번째(단일) 값만을 고려합니다.

first()

호출한 Observable 객체의 첫 번째 항목 값을 포함하는 새로운 Observable을 반환합니다.

1
2
var values = Observable(1, 2, 3);
var firstEntry = values.first(); //Observable(1)

flatMap(func(item))

Observable의 모든 항목에 대해 func을 호출한 다음 모든 func 호출 항목을 하나의 Observable 배열로 병합합니다.

1
2
3
4
5
6
7
8
var numbers = Observable(
    [1, 2, 3],
    [4, 5, 6]
);
var counts = numbers.flatMap(function(item) {
    return [item, item+1];
});
//counts == Observable([1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7])

inner()

두 Observable이 중첩될 때 내부 값을 반영하는 새로운 Observable을 반환합니다 (Observable의 .value는 Observable 임). Observable이 호출되면 Observable이 중첩되지 않으면 .inner()는 단순히 값을 반영합니다.

현재 Observable이 중첩되지 않은 경우 반환된 Observable 객체는 현재 Observable 객체의 값을 반영합니다.

1
2
3
4
var foo = Observable(Observable(4))
var bar = foo.inner(); // bar.value = 4
foo.value.value = 9;   // bar.value = 9
foo.value = 3;         // bar.value = 3

이것은 ux:Property를 통해 전달된 Observable을 처리할 때 특히 유용합니다.

last()

호출한 Observable 객체에서 마지막 항목의 값을 포함하는 새로운 Observable을 리턴합니다.

1
2
var values = Observable(1, 2, 3);
var lastEntry = values.last(); //Observable(3)

map(func(item)))

Observable의 모든 값에 대해 func을 호출하여 새로운 Observable에 결과를 반환합니다.

1
2
3
4
var numbers = Observable(1, 4, 9);
var roots = numbers.map(function(number) {
    return Math.sqrt(number);
});

roots의 값은 숫자의 제곱근이 됩니다. 숫자의 값은 변경되지 않습니다.

map(func(item, index)))

Observable의 모든 값에 대해 func을 호출하여 새로운 Observable에 결과를 반환합니다.

1
2
3
4
var numbers = Observable("this", "item", "is");
var roots = numbers.map(function(item, index) {
    return item + " has the index nr: " + index;
});

Observable.map이 두 개의 인수를 취하는 함수와 함께 사용될 때 두 번째 인수는 Observable에서 해당 항목의 인덱스입니다.

mapTwoWay(mapFunc(sourceValue), unmapFunc(partValue,sourceValue))

출력과의 양방향 바인딩을 만드는 map 버전입니다. 리턴된 Observable에서 수정된 값은 소스 observable의 값을 갱신합니다.

mapFunc(sourceValue)는 소스 observable에서 값을 변환합니다. 출력에 대해 매핑된 값을 반환합니다.

unmapFunc(partValue, sourceValue)는 출력 값을 입력 양식으로 다시 변환합니다. 현재의 sourceValue는 출력이 일부 값일 경우를 대비하여 제공됩니다.

다음은 radians을 degrees 단위로 변환하기 위한 간단한 매핑의 예입니다(이 예에서는 sourceValue가 필요하지 않습니다).

1
2
3
4
5
6
var angles = Observable(0, Math.PI, 2*Math.PI)
exports.angleDegrees = angles.mapTwoWay( function(value) {
    return value * 180 / Math.PI
}, function( value, sourceValue ) {
    return value * Math.PI / 180
})

다음은 객체의 필드를 반환하고 umapFunc에서 전체 객체를 다시 만드는 예제입니다. 이것이 전부라면 pickTwoWay를 대신 사용하십시오. 정확히 이 작업을 수행합니다(이 예에서는 users.pickTwoWay(“name”)).

1
2
3
4
5
6
7
8
9
10
11
var users = Observable(
    { id: "tom", name: "Tommy" },
    { id: "sal", name: "Sally" }
)

exports.names = users.mapTwoWay( function(user) {
    return user.name
}, function( name, sourceUser ) {
    sourceUser.name = name
    return sourceUser
})

not()

호출하고 있는 Observable의 반대(inverse) 값을 가진 Observable을 반환합니다. Observable이 true인 경우 반환되는 객체는 false가 되며 그 반대의 경우도 마찬가지입니다.

1
2
falseValue = Observable(false);
trueValue = falseValue.not();

pick(index)

호출된 Observable에서 모든 아이템의 인덱스 또는 명명된 속성에 있는 아이템을 포함하는 새로운 Observable을 반환합니다.

1
2
var values = Observable([1, 2], [3, 4], [5, 6]);
var picked_values = values.pick(1); //Observable(2, 4, 6);

pickTwoWay(index)

pick과 마찬가지로 양방향 관계를 만듭니다. 소스 맵을 수정하면 소스 맵의 값이 업데이트 됩니다.

slice([begin[, end]])

현재 Observable 요소의 슬라이스를 반영하는 새로운 observable을 반환합니다.

이 함수의 인수에 대한 설명은 Array.slice() 설명서를 참조하십시오.

1
2
var foo = Observable(1,2,3,4);
var bar = foo.slice(1,2) // bar = Observable[2, 3]

힌트:

  • Observable 객체의 첫 번째 요소를 관측하려면 .slice(0, 1)을 사용하십시오.
  • Observable 객체의 마지막 요소를 관찰하려면 .slice(-1)를 사용하십시오.

where(condition)

condition은 함수 또는 객체가 될 수 있습니다. condition이 함수이면 조건이 true를 반환하는 값만 있는 새 Observable을 반환합니다. 그러나 condition이 객체이면 엄격한 동일 조건(===)을 사용하여 검사한 매개 변수가 조건의 매개 변수와 일치하는 값만 가진 새 Observable을 반환합니다.

새로운 Observable은 이전 Observable을 관찰하므로 원본 Observable이 변경될 때마다 업데이트 됩니다.

1
2
3
4
5
6
7
8
9
10
11
fruits = Observable(
    { name: "Apple" , color: "red"    },
    { name: "Lemon" , color: "yellow" },
    { name: "Pear"  , color: "green"  },
    { name: "Banana", color: "yellow" });

goodFruits = fruits.where({color: "yellow"});

goodFruits = fruits.where(function(e){
    return e.color === "yellow";
});

참고! 당신은 조건 자체를 관찰 가능하게 만들기 위해 .where 연산자로 Observable 함수를 반환할 수 있어야 했습니다. 그것은 더 이상 허용되지 않습니다. 동일한 효과를 얻는 가장 좋은 방법은 대신 flatMap()을 사용하는 것입니다.

observable 조건에 따라 목록을 필터링하려면 .flatMap과 .where의 조합을 사용하십시오.

1
2
3
var items = conditionObservable.flatMap(function(v) {
    return itemsObservable.where(function(x) { return v != x; });
});

우리는 매핑 함수에서 관측 값을 반환하기 때문에 .map() 대신 .flatMap()을 사용합니다.

참고! 위의 접근법은 빠르지만 관찰할 수 있는 조건이 변경되는 경우 Observable 아이템에서 아이템 순서를 보존하지는 않습니다. 이는 Observable 아이템이 효과적으로 삭제되고 처음부터 채워지는 것을 의미합니다. 이 문제가 없는 .where를 가진 조건을 관찰하기 위한 두 번째 패턴이 있지만 큰 목록에서는 잠재적으로 느릴 수 있습니다. 여기에는 완전성을 위해 포함됩니다.

1
2
3
4
5
var filteredItems = conditionObservable.flatMap(function(cond){
    return items.where(function(item){
        return cond.value;
    });
});

완전한 샘플을 보려면 여기를 방문하세요.

이렇게 하면 조건이나 데이터가 변경될 때마다 변경 사항을 푸시하는 Observable을 만들 수 있습니다.

업데이트 구독

onValueChanged(module,func)

Observable의 변경 사항에 수동으로 대응하기 위해 onValueChanged 메소드를 사용할 수 있습니다. 자동으로 구독을 생성하고 수명을 모듈과 연결합니다. Observable이 변경될 때마다 func가 호출됩니다.

1
2
3
someObservable.onValueChanged(module, function(x) {
    console.log("We got a new value: " + x);
});

addSubscriber(func)

Observable에 대한 구독을 수동으로 만들 수 있습니다. 적절한 시간에 removeSubscriber를 사용하여 구독을 수동으로 제거해야 합니다. 이런 이유로 사용자 정의 Observable 연산자를 구현하지 않는 한 항상 onValueChanged를 사용하는 것이 좋습니다.

removeSubscriber(func)

Observable에서 값을 소비한 후에는 구독을 제거하여 정리하는 것이 중요합니다. 이렇게 하지 않으면 시간이 지남에 따라 메모리 가비지가 누적될 수 있습니다. addSubscriber를 사용하여 수동으로 구독을 만든 경우에만 필요합니다. onValueChanged가 자동으로 이 정리 작업을 처리한다는 점을 기억하십시오.

1
username.removeSubscriber(usernameLogger);

Observable로 비동기 데이터 가져오기

Observable 변경의 값에 대한 응답으로 일부 데이터를 비동기적으로 요청하고 결과를 다른 Observable로 가져와야 하는 경우가 있습니다. 우리는 map()과 inner()의 조합을 사용하여 우아한 방법으로 이 작업을 수행할 수 있습니다.

아래 예제에서, 우리는 입력된 Observable의 각 아이템(이 경우 하나)을 매핑(map 함수)하고, Observable을 반환합니다. Observable은 가져온 데이터를 사용할 수 있게 되면 업데이트할 Observable을 반환합니다. 이것은 우리의 미래 데이터를 관찰할 수 있는 Observable을 가져올 것입니다 – 거의 우리가 원하는 것. 그러므로 우리는 inner()를 사용하여 외부의 위치 대신 Observable 내부를 “unwrap” 합니다, 그리고 짜잔! 우리는 입력이 변경될 때마다 비동기적으로 가져온 데이터로 업데이트될 Observable로 끝납니다.

1
2
3
4
5
6
7
8
9
10
11
12
13
var inputUrl = Observable("https://example.com/");

var output = inputUrl.map(function(url) {
    var resultObservable = Observable("Placeholder value");

    fetch(url)
        .then(function(response) { return response.text(); })
        .then(function(result) {
            resultObservable.value = result;
        });

    return resultObservable;
}).inner();

Failures

Observable이 실패한 상태일 수 있습니다. 즉, 값을 제공할 수 없으며 현재 값이 지워졌다는 의미입니다. Observable은 네트워크 요청과 같은 최종 공급자가 값을 제공할 수 없는 경우 실패한 것으로 표시됩니다.

실패한 상태는 Observable에 새 값이 기록 되자마자 지워집니다(이 호출에는 clear 호출이 포함됨).

failed(message)

Observable을 failed로 표시합니다. 메시지는 실패한 것에 대한 텍스트 정보를 제공하는 문자열이어야 합니다.

getFailure()

현재의 실패 메세지를 돌려줍니다. Observable이 실패한 상태가 아닌 경우 undefined 됩니다.

isFailed([obs, …])

boolean 값을 가지는 새로운 Observable를 돌려줍니다. 이것은, 소스 관측 가능이 실패했을 경우는 true가 됩니다.

추가 Observable을 인수로 제공할 수 있습니다. 부울 값은 원본 개체를 포함하여 이러한 Observable 중 하나라도 실패할 때마다 true가 됩니다.

failedMap(failedMapFunc [, notFailedMapFunc ])

실패한 상태를 새로운 값에 매핑하는 새로운 Observable을 돌려줍니다.

소스 Observable이 실패하면 failedMapFunc(message)이 호출됩니다. 반환 값은 Observable 출력 값으로 사용됩니다.

소스 Observable이 실패하지 않았거나 실패 상태에서 회복되면 notFailedMapFunc()이 호출됩니다. 반환 값은 Observable 출력 값으로 사용됩니다. 이 함수가 제공되지 않거나 undefined를 반환하면 Observable 출력이 지워집니다.

onFailed(module, onFailedCallback [, onFailedResolvedCallback])

비상 사태에 대응하기 위해 onFailed 함수를 사용할 수 있습니다. 자동으로 구독을 생성하고 수명을 모듈과 연결합니다.

Observable이 실패할 때마다 onFailedCallback(message)이 호출됩니다. 메시지는 실패한 기능에 제공된 메시지입니다.

Observable에 실패한 상태가 재설정될 때마다 onFailedResolvedCallback이 호출됩니다.

onFailed를 호출하면 현재 상태에 따라 두 함수 중 하나가 호출됩니다.

기타

toString()

Observable과 그 내용의 문자열 표현을 반환합니다.

1
2
var testObservable = Observable(1, "two", "3");
testObservable.toString(); // "(observable) 1,two,3"
Was this article helpful to you? Yes No

How can we help?