LiveScript 함수
The LiveScript Book
함수
정의 함수는 매우 경량급이다.
1.(x, y) -> x + y
2.
3.-> # an empty function
4.
5.times = (x, y) ->
6. x * y
7.
8.#
1.var times;
2.(function(x, y) {
3. return x + y;
4.});
5.(function() {});
6.times = function(x, y) {
7. return x * y;
8.};
함수의 정의는 항상 회색으로 짧지 않습니까!
함수 호출
너는 함수 호출할 때의 괄호를 생략할 수 있다. 어떻게 실제 매개 변수를 호출할 수 있는지, 심지어는 실참 사이의 쉼표를 생략할 수도 있고, 앞에서 말한 목록과 같은 덕행을 보일 수도 있다.
1.x = 4
2.Math.pow x, 3 # => 64
3.Math.pow 2 3 # => 8
무참 함수를 호출할 때, 함수 이름 뒤에
!
를 추가하면 되고, 함수의 체인 호출도 .
링크를 사용하지 않아도 된다.1.f!
2.
3.[1 2 3].reverse!slice 1
1.f();
2.[1, 2, 3].reverse().slice(1);
and
,or
,xor
,.
또는?.
함수의 실참 목록을 마무리하면 괄호를 절약한 후 체인 호출을 실행할 수 있다.1.$ \h1 .find \a .text!
1.$('h1').find('a').text();
너는
do
로 즉시 무참함수를 호출할 수 있다.1.do -> 3 + 2
1.(function() {
2. return 3 + 2;
3.})();
do
표현식에 사용하지 않을 때, 당신은 do
명명 함수에 작용할 수 있으며, 작용 후에 이 함수가 존재합니다!1.i = 0
2.
3.f 9 # => 9
4.
5.i # => 1
6.
7.do function f x
8. ++i
9. x
10.
11.i # => 2
12.
13.ff = do function gg x
14. x + 2
1.var i, ff;
2.i = 0;
3.f(9);
4.i;
5.
6.function f(x) {
7. ++i;
8. return x;
9.}
10.f();
11.i;
12.ff = (function() {
13. function gg(x) {
14. return x + 2;
15. }
16. return gg;
17.}())();
함수에 대상을 전달하려면
do
를 사용해야 한다1.func do
2. a: 1
3. b: 2
1.func({
2. a: 1,
3. b: 2
4.});
do
괄호 없이 많은 일을 할 수 있게 해준다.1.pow do
2. 1
3. 2
4.
5.h 1 do
6. a: 2
7. b: 5
1.pow(1, 2);
2.
3.h(1, {
4. a: 2,
5. b: 5
6.});
너는 접두사 표현식과 유사한 형식으로 함수 호출을 할 수 있다.
1.add = (x, y) -> x + y
2.
3.3 `add` 4 # => 7
1.var add;
2.add = function(x, y) {
3. return x + y;
4.};
5.add(2, 4);
함수를 호출할 때
...
현재 함수의 실참을 사용하여 이 함수를 호출합니다.호출 super
시 특히 유용합니다.1.f = (x, y) ->
2. x + y
3.
4.g = (a, b) ->
5. f ...
6.
7.g 3 4 # => 7
1.var f, g;
2.f = function(x, y) {
3. return x + y;
4.};
5.g = function(a, b) {
6. return f.apply(this, arguments);
7.};
8.g(3, 4);
매개 변수
확장된 매개변수:
1.set-person-params = (
2. person
3. person.age
4. person.height
5.) -> person
6.
7.person = set-person-params {}, 21, 180cm
8.
9.# => Object {age: 21, height: 180}
1.var setPersonParams, person;
2.setPersonParams = function(person, age, height) {
3. person.age = age;
4. person.height = height;
5. return person;
6.};
7.person = setPersonParams({}, 21, 180);
확장 매개변수 및
this
:1.set-text = (@text) -> this
1.var setText;
2.setText = function(text) {
3. this.text = text;
4. return this;
5.};
기본 매개 변수를 설정할 수 있습니다.
1.add = (x = 4, y = 3) -> x + y
2.
3.add 1 2 # => 3
4.add 1 # => 4
5.add! # => 7
1.var add;
2.add = function(x, y){
3. x == null && (x = 4);
4. y == null && (y = 3);
5. return x + y;
6.};
7.add(1, 2);
8.add(1);
9.add();
또는 논리 연산자(매개 변수 중
x = 2
는 x ? 2
문법 설탕일 뿐입니다.1.add = (x && 4, y || 3) -> x
2.
3.add 1 2 # => 6
4.add 2 0 # => 7
1.var add;
2.add = function(x, y) {
3. x && (x = 4);
4. y || (y = 3);
5. return x;
6.};
7.add(1, 2);
8.add(2, 0);
너도 매개 변수를 해독할 수 있다.
1.set-cords = ({x, y}) -> "#x, #y"
2.set-cords y: 2, x: 3 # => '3, 2'
1.var setCords;
2.setCords = function(arg$){
3. var x, y;
4. x = arg$.x, y = arg$.y;
5. return x + ", " + y;
6.};
7.setCords({
8. y: 2,
9. x: 3
10.});
매개변수 분석 시 기본 매개변수를 설정할 수도 있습니다.
1.set-cords = ({x = 1, y = 3} = {}) ->
2. "#x,#y"
3.set-cords y: 2, x: 3 # => '3,2'
4.set-cords x: 2 # => '2,3'
5.set-cords y: 7 # => '1,7'
6.set-cords! # => '1,3'
1.var setCords;
2.setCords = function(arg$) {
3. var ref$, x, ref1$, y;
4. ref$ = arg$ != null ? arg$ : {}, x = (ref1$ = ref$.x) != null ? ref1$ : 1, y = (ref1$ = ref$.y) != null ? ref1$ : 3;
5. return x + "," + y;
6.};
7.setCords({
8. y: 2,
9. x: 3
10.});
11.setCords({
12. x: 2
13.});
14.setCords({
15. y: 7
16.});
17.setCords();
너도 매개 변수에서 사용할 수 있다
...
:1.f = (x, ...ys) -> x + ys.1
2.
3.f 1 2 3 4 # => 4
1.var f, slice$ = [].slice;
2.f = function(x) {
3. var ys;
4. ys = slice$.call(arguments, 1);
5. return x + ys[1];
6.};
7.f(1, 2, 3, 4);
너는 심지어 너의 매개 변수 목록에서 일원 연산자를 사용할 수 있다.너는
+
과!!
를 사용하여 파라미터를 각각 숫자와 볼 형식으로 바꾸거나 복제 조작부호^^
를 사용하여 대상에 대한 어떠한 조작도 원래의 대상에 영향을 주지 않도록 보장할 수 있다.너는 여전히 확장 파라미터를 사용할 수 있다. 예를 들면:
(!!x.x)->
.1.f = (!!x) -> x
2.f 'truthy string' # => true
3.
4.g = (+x) -> x
5.g '' # => 0
6.
7.obj =
8. prop: 1
9.h = (^^x) ->
10. x.prop = 99
11. x
12.h obj
13.obj.prop # => 1
1.var f, g, obj, h;
2.f = function(x) {
3. x = !!x;
4. return x;
5.};
6.f('truthy string');
7.g = function(x) {
8. x = +x;
9. return x;
10.};
11.g('');
12.obj = {
13. prop: 1
14.};
15.h = function(x) {
16. x = clone$(x);
17. x.prop = 99;
18. return x;
19.};
20.h(obj);
21.obj.prop;
22.
23.function clone$(it) {
24. function fun() {}
25. fun.prototype = it;
26. return new fun;
27.}
콜리화
콜리화 함수는 매우 강하다.본질적으로 말하면 하나의 함수가 호출될 때 실삼 개수가 형삼의 개수보다 적으면 편향 응용 함수로 되돌아온다.즉, 되돌아오는 함수의 인삼은 네가 방금 인삼에 대응하지 않은 인삼이며, 이미 준 인삼은 자동으로 귀속된다.LiveScript에서 함수 콜리화를 수행하려면 긴 화살표를 사용합니다.아마도 하나의 예가 문제를 더욱 분명하게 말할 수 있을 것이다.
1.times = (x, y) --> x * y
2.times 2, 3 # => 6 (normal use works as expected)
3.double = times 2
4.double 5 # => 10
1.var times, double;
2.times = curry$(function(x, y) {
3. return x * y;
4.});
5.times(2, 3);
6.double = times(2);
7.double(5);
8.
9.function curry$(f, bound) {
10. var context,
11. _curry = function(args) {
12. return f.length > 1 ? function() {
13. var params = args ? args.concat() : [];
14. context = bound ? context || this : this;
15. return params.push.apply(params, arguments) <
16. f.length && arguments.length ?
17. _curry.call(context, params) : f.apply(context, params);
18. } : f;
19. };
20. return _curry();
21.}
~~>
를 사용하여 콜리화의 한계 함수를 정의할 수 있습니다.만약 매개 변수를 가지고 콜리화된 함수를 호출하지 않는다면, 기본 매개 변수를 설정할 수 있습니다.
1.f = (x = 5, y = 10) --> x + y
2.
3.f! # => 15
4.
5.g = f 20
6.g 7 # => 27
7.g! # => 30
1.var f, g;
2.f = curry$(function(x, y) {
3. x == null && (x = 5);
4. y == null && (y = 10);
5. return x + y;
6.});
7.f();
8.g = f(20);
9.g(7);
10.g();
11.
12.function curry$(f, bound) {
13. var context,
14. _curry = function(args) {
15. return f.length > 1 ? function() {
16. var params = args ? args.concat() : [];
17. context = bound ? context || this : this;
18. return params.push.apply(params, arguments) <
19. f.length && arguments.length ?
20. _curry.call(context, params) : f.apply(context, params);
21. } : f;
22. };
23. return _curry();
24.}
명명 함수
명명 함수를 만들어서 이 함수의 작용역을 향상시킬 수 있습니다.상단이 아닌 파일 끝에 효용 함수를 정의하는 데 매우 유용하다.명명 함수는 수정할 수 없고 재정의할 수 없습니다!
1.util! # => ' '
2.
3.util2! # => 2
4.
5.function util
6. ' '
7.function util2 then 2
1.util();
2.util2();
3.
4.function util() {
5. return ' ';
6.}
7.
8.function util2() {
9. return 2;
10.}
명명 함수 전치
~
를 통해 명명 함수를 한정 함수로 만듭니다.1.~function add x, y
2. @result = x + y
1.var this$ = this;
2.
3.function add(x, y) {
4. return this$.result = x + y;
5.}
명명된 함수 선행자
!
에서 자동 반환을 취소할 수 있습니다.1.util! # =>
2.!function util x then x
1.util();
2.
3.function util(x) {
4. x;
5.}
명명 함수를 원하는 대로 한정하고 반환 값이 없도록 조합해서 사용할 수 있습니다.
한정 함수
~
를 사용하여 한정 함수를 정의하고, !
을 사용하여 코리화의 한정 함수를 정의한다.한정 함수 어법이 귀속되었고~>
, 평소처럼 동적 귀속은 아니다.즉, 어떤 상하문에서 이 함수를 호출하든지 함수 체내의 ~~>
는 정의할 때 가리키는 this
을 시종 유지한다.1.obj = new
2. @x = 10
3. @normal = -> @x
4. @bound = ~> @x
5.
6.obj2 = x: 5
7.obj2.normal = obj.normal
8.obj2.bound = obj.bound
9.
10.obj2.normal! # => 5
11.obj2.bound! # => 10
1.var obj, obj2;
2.obj = new function() {
3. var this$ = this;
4. this.x = 10;
5. this.normal = function() {
6. return this.x;
7. };
8. this.bound = function() {
9. return this$.x;
10. };
11.};
12.obj2 = {
13. x: 5
14.};
15.obj2.normal = obj.normal;
16.obj2.bound = obj.bound;
17.obj2.normal();
18.obj2.bound();
let, new
this
은this
의 약자입니다.1.let x = 2
2. console.log x
1.(function(x) {
2. console.log(x);
3.}.call(this, 2));
너도
let
정의(function(a){...}.call(this, b))
를 사용할 수 있다(즉, let
:1.x = let @ = a: 1, b: 2
2. @b ^ 3
3.x # => 8
1.var x;
2.x = (function() {
3. return Math.pow(this.b, 3);
4.}.call({
5. a: 1,
6. b: 2
7.}));
8.x;
새 컨텍스트:
1.dog = new
2. @name = \spot
3. @mutt = true
4.
5.# => Object {name: "spot", mutt: true}
1.var dog;
2.dog = new function() {
3. this.name = 'spot';
4. this.mutt = true;
5.};
함수 접근 | 호출된 약자
this
및 @
등 이런 고급 함수에 대해 이것은 매우 유용하다.map
은filter
의 약자입니다.번역 주: 관련된
(.prop)
, (it) -> it.prop
, map
및 filter
함수는 모두 head
1.map (.length), <[ hello there you ]>
2.# => [5, 5, 3]
3.
4.filter (.length < 4), <[ hello there you ]>
5.# => ['you']
1.map(function(it) {
2. return it.length;
3.}, ['hello', 'there', 'you']);
4.filter(function(it) {
5. return it.length < 4;
6.}, ['hello', 'there', 'you']);
너도 이것으로 방법을 호출할 수 있다.
1.map (.join \|), [[1 2 3], [7 8 9]]
2.# => ['1|2|3', '7|8|9']
1.map(function(it) {
2. return it.join('|');
3.}, [
4. [1, 2, 3],
5. [7, 8, 9]
6.]);
revers
은 prelude.ls
의 약자입니다.1.obj =
2. one: 1
3. two: 2
4. three: 3
5.
6.map (obj.), <[ one three ]>
7.# => [1, 3]
1.var obj;
2.obj = {
3. one: 1,
4. two: 2,
5. three: 3
6.};
7.map(function(it) {
8. return obj[it];
9.}, ['one', 'three']);
리셋 함수
리셋 함수 회색 상시 회색 상시 유용, 리셋의 비접착을 허용합니다.왼쪽으로 화살표로 정의하고 나머지는 일반적인 함수와 마찬가지로
(obj.)
한정함수를 정의하고 (it) -> obj[it]
과 <~
각각 코리화된 한정함수와 코리화된 일반 함수를 정의하며 <~~
으로 자동 반환을 취소한다.1.<- f
2.alert \boom
1.f(function() {
2. return alert('boom');
3.});
함수의 매개 변수를 설정할 수 있고, 리셋 함수가 있는 인삼의 위치를 지정할 수 있습니다.
1.x <- map _, [1 to 3]
2.x * 2
3.# => [2, 4, 6]
1.map(function(x) {
2. return x * 2;
3.}, [1, 2, 3]);
만약 당신의 리셋 함수 뒤에 다른 코드가 포함된다면,
<--
문장을 사용해서 그들을 분리할 수 있습니다.1.do
2. data <-! $.get \ajaxtest
3. $ '.result' .html data
4. processed <-! $.get \ajaxprocess, data, _
5. $ '.result' .append processed
6.
7.alert \hi
1.$.get('ajaxtest', function(data) {
2. $('.result').html(data);
3. $.get('ajaxprocess', data, function(processed) {
4. $('.result').append(processed);
5. });
6.});
7.alert('hi');
편함수 응용
너는 밑줄을 사용해서
<-!
자리를 차지하는 문자로 편함수 응용을 할 수 있다.때때로 당신이 처리해야 할 함수는 콜리화되지 않았거나 그 형삼 목록의 순서가 이상적이지 않다. 이런 상황에서 편함수는 특히 유용해진다.1.filter-nums = filter _, [1 to 5]
2.
3.filter-nums even # => [2, 4]
4.filter-nums odd # => [1, 3, 5]
5.filter-nums (< 5) # => [1, 2]
1.var filterNums, slice$ = [].slice;
2.filterNums = partialize$.apply(this, [filter, [void 8, [1, 2, 3, 4, 5]],
3. [0]
4.]);
5.filterNums(even);
6.filterNums(odd);
7.filterNums((function(it) {
8. return it < 5;
9.}));
10.
11.function partialize$(f, args, where) {
12. var context = this;
13. return function() {
14. var params = slice$.call(arguments),
15. i,
16. len = params.length,
17. wlen = where.length,
18. ta = args ? args.concat() : [],
19. tw = where ? where.concat() : [];
20. for (i = 0; i < len; ++i) {
21. ta[tw[0]] = params[i];
22. tw.shift();
23. }
24. return len < wlen && len ?
25. partialize$.apply(context, [f, ta, tw]) : f.apply(context, ta);
26. };
27.}
매개 변수를 가지고 편함수를 호출하지 않으면, 기본 매개 변수를 사용할 수 있도록 되돌려줍니다.
파이프를 사용할 때 편함수도 매우 유용하다. 특히 파라미터 목록이 우아하지 않고 콜리화되지 않았다.
1.[1 2 3]
2.|> _.map _, (* 2)
3.|> _.reduce _, (+), 0
4.# => 12
1._.reduce(_.map([1, 2, 3], (function(it) {
2. return it * 2;
3.})), curry$(function(x$, y$) {
4. return x$ + y$;
5.}), 0);
6.
7.function curry$(f, bound) {
8. var context,
9. _curry = function(args) {
10. return f.length > 1 ? function() {
11. var params = args ? args.concat() : [];
12. context = bound ? context || this : this;
13. return params.push.apply(params, arguments) <
14. f.length && arguments.length ?
15. _curry.call(context, params) : f.apply(context, params);
16. } : f;
17. };
18. return _curry();
19.}
형삼
만약 매개 변수가 하나밖에 없다면, 매개 변수를 정의할 필요가 없습니다.
do
매개 변수에 접근할 수 있습니다.1.f = -> it + 2
2.f 3 # => 5
1.var f;
2.f = function(it) {
3. return it + 2;
4.};
5.f(3);
_
를 사용하여 it
대상에 접근합니다. 첫 번째 파라미터는 &
, 두 번째 파라미터는 arguments
입니다.&0
바로 &1
.1.add-three-numbers = -> &0 + &1 + &1
2.add-three-number 1 2 3 # => 6
1.var addThreeNumbers;
2.addThreeNumbers = function() {
3. return arguments[0] + arguments[1] + arguments[1];
4.};
5.addThreeNumber(1, 2, 3);
이러한 상황에서 콜리화는 발생하지 않을 수 있습니다. 왜냐하면
&
성명된 매개 변수의 개수는 arguments
이기 때문입니다.이 내용에 흥미가 있습니까?
현재 기사가 여러분의 문제를 해결하지 못하는 경우 AI 엔진은 머신러닝 분석(스마트 모델이 방금 만들어져 부정확한 경우가 있을 수 있음)을 통해 가장 유사한 기사를 추천합니다:
다양한 언어의 JSONJSON은 Javascript 표기법을 사용하여 데이터 구조를 레이아웃하는 데이터 형식입니다. 그러나 Javascript가 코드에서 이러한 구조를 나타낼 수 있는 유일한 언어는 아닙니다. 저는 일반적으로 '객체'{}...
텍스트를 자유롭게 공유하거나 복사할 수 있습니다.하지만 이 문서의 URL은 참조 URL로 남겨 두십시오.
CC BY-SA 2.5, CC BY-SA 3.0 및 CC BY-SA 4.0에 따라 라이센스가 부여됩니다.