다음은 대부분 옳습니다. 내가 놓친 것이 있거나 잘못 이해한 것이 있을 수 있습니다. 링크된 문서를 읽고(너무 짧음) 댓글을 달아주세요. 감사합니다.
나쁜 비유 : 클래스는 쿠키 커터입니다. 인스턴스는 쿠키 커터로 만든 쿠키입니다.
비유의 문제 : JSL에도 전화하겠습니다. 수업 ㅏ 원기 . 프로토타입은 실제 쿠키입니다. 프로토타입 쿠키 ~할 수 있었다 먹거나 개조할 수 있지만 일반적으로 그렇게 하고 싶지는 않을 것입니다. 대신 윤곽선을 쿠키 반죽에 대고 가위로 잘라 새로운 쿠키 인스턴스를 만들어야 합니다. 그러나 프로토타입 쿠키를 한 입 베어 물면 이후의 모든 쿠키 인스턴스도 물린 것처럼 보일 것입니다(두 번째 예). 또한 프로토타입 쿠키에 대해 _init_(...) 메서드가 실행되지 않아 반쯤 구워졌을 수 있지만 올바른 모양을 가지고 있습니다.
그만큼 선적 서류 비치 용도 주형 오히려 원기 . 저는 템플릿보다 프로토타입을 선호합니다. 프로토타입은 사용 가능한 개체인 반면 템플릿은 스프레이 페인트가 어디로 가야 하는지 보여줍니다. 이 미묘한 구분은 첫 번째 예에서는 중요하지 않습니다.
간단한 예
다음은 간단한 단일 클래스 예제입니다. 거품 . 클래스 프로토타입은 DefineClass()에 의해 만들어집니다. NewObject()는 프로토타입의 실제 인스턴스 61개. 61개의 인스턴스 각각에는 반지름과 x,y 중심이 있습니다. 프로토타입은 _init_(...), drift() 및 draw()에 대한 메서드도 제공합니다. 개체를 사용하여 그래프가 표시됩니다. 각 개체에 대한 그리기 메서드입니다. 그런 다음 루프가 실행되어 각 개체에 대한 개체 드리프트 메서드를 호출한 다음 그래프에 다시 그리도록 지시합니다. 결과는 다음과 같은 애니메이션 그래프입니다.
그래프의 JSL:
// define a simple class (like a template) to represent a 2D bubble
Define Class("bubble",
// class member variables
m_radius = .; // class member variables are specified in
m_xpos = .; // the class definition with initial values.
m_ypos = .; // these values are copied into instances created by NewObject(...)
// class methods
_init_ = Method( {radius, x, y}, // called by NewObject(bubble(r,x,y)) below to initialize an instance
this:m_xpos = x; // this: is the namespace of an instance
m_ypos = y; // you don't need "this:" unless the member name is
m_radius = radius; // the same as a parameter name
);
drift = Method( {}, // a method to move the bubble
m_xpos = m_xpos * 0.995;// tentatively drift to center
m_ypos = m_ypos * 0.995;
);
draw = Method( {}, // a method to draw the bubble
Circle( {m_xpos, m_ypos}, m_radius )
);
);
// make a bunch of instances of the bubble class, keep them in a list
bubblelist = {};
For( i = 1, i <= 61, i += 1,
Insert Into( bubblelist,
// each instance of bubble is initialized with a random radius and position
New Object( bubble( Random Uniform( .03, .8 ), Random Uniform( -.9, .9 ), Random Uniform( -.9, .9 ) ) )
)
);
picno = 0; // need an ID for each picture
// make a window to display all the instances of the bubble class
New Window( "bubble class instances",
gb = Graph Box( // the graphic script for the graph box scales and sizes the axes and...
xaxis( {Add Ref Line( 0, "Solid", "Black", "", 1 )} ),
yaxis( {Add Ref Line( 0, "Solid", "Black", "", 1 )} ),
framesize( 600, 600 ),
X Scale( -1, 1 ),
Y Scale( -1, 1 ),
// the graphic script tells each bubble to draw itself
For( i = 1, i <= N Items( bubblelist ), i += 1,
bubblelist[i]:draw()
);
text({-.9,-.9},char(picno)),
<<ONCLOSE></ONCLOSE>작동 방식에 대한 내 정신 모델: 표지 아래에서 DefineClass()는 모든 DefineClass() 프로토타입의 숨겨진 목록을 유지하고 많이 인스턴스처럼. 잠시 후에 더 자세히 알아보십시오. 위의 예제에서는 NewObject() 함수를 통해 액세스합니다. NewObject()는 프로토타입 객체의 새 인스턴스를 복제하고 _init_ 메서드를 실행합니다.
뭐야 이것: ?
위의 예에서 멤버 변수의 이름을 다음과 같이 지정했습니다. 미디엄_ 접두사. 필수는 아니지만 어떤 변수가 멤버 변수인지 기억하고 매개 변수 이름 및 지역 변수 이름과의 충돌을 방지하는 데 유용할 수 있습니다. 하지만 나도 사용 이것:m_xpos _init_() 메서드 할당 중 하나에서. 그만큼 이것: namespace는 "현재 인스턴스의 멤버 변수"를 의미합니다. 그래서 이것:x = x; 멤버 변수 x와 매개변수 x가 같은 이름을 갖도록 하려는 경우에 사용할 수 있습니다. 미디엄_ 코드를 유지 관리하는 다음 사람이 더 쉬울 것입니다.
뭐야 거품: ?
다른 네임스페이스가 있습니다. 대부분 필요하지 않은 내가 왜 숨겨진 목록에서 DefineClass() 프로토타입이 보이는지 보여줄 것입니다. 많이 like instance--클래스 이름 ~이다 네임스페이스. 사용 거품:m_radius 인스턴스 메서드에서도 프로토타입의 m_radius에 액세스합니다. 정적 멤버 변수가 필요하다고 생각되면 주의해서 만들 수 있는 방법입니다.
정적 값에 대한 프로토타입 사용
다음 예제에서는 정적 m_ID 변수를 사용합니다. 의견에서 알 수 있듯이 다른 변형을 만들었어야 했지만 "조심한다면" 경고를 설명하기 때문에 여전히 유용합니다. 다음과 같은 일이 발생합니다(내 정신 모델).
아래의 _init_()가 실행될 때 bubble2 클래스는 이미 모든 프로토타입 콘텐츠를 새 인스턴스에 복사했습니다. 새 인스턴스에는 프로토타입의 m_id 복사본이 있습니다. _init_()는 프로토타입에서 m_id()를 변경합니다. 다음 인스턴스는 변경된 값을 가져옵니다. 다른 멤버 함수는 프로토타입의 m_id(bubble2:m_id)와 this:m_id(또는 네임스페이스가 없는 m_id) 중에서 선택해야 합니다. 여기서는 인스턴스에 고유한 정수의 복사본인 m_id를 사용합니다.
영상 속 마지막 퍼즐 조각은 화면 하단 5분 15초 지점에 맞춰진다. 검은색 원은 m_id 값을 표시하는 bubble2입니다. 그들은 모든 가까운 이웃을 연구할 때 자신을 무시하도록 m_id를 사용합니다.
// twist is a scaling divisor for a shearing rotation that moves
// the outer edge faster.
// this value needs to get bigger with more beehive cells.
global:twist = 600;
// choose the size to make them fit, but it also interacts with twist
// because the distance from the center grows
global:bubblesize = 0.057;
// use a defined class to represent each cell in the beehive.
Define Class("bubble2",
m_radius = .; // in the video, all beehive cells have the same radius
m_xpos = .; // the beehive cell's position
m_ypos = .;
//
// this is answering the question "can a JSL Class have a static member variable?"
// this could have been done more intuitively for this example by passing the
// index of the creation loop to the _init_ code, but here it is...initialize the
// "static" value to 1...
m_id = 1; // keep reading to understand the two-faced nature of this variable...
// What actually happens: when newObject(bubble2(...)) makes a new instance, the _init_(...)
// is called.
// First, the m_id is cloned from the prototype to the instance. The first instance gets m_id==1.
// Second, the bubble2: namespace causes the prototype class to increment the
// prototype's m_id. The next instance gets the new value from the prototype, m_id==2.
// this is a little odd, coming from a C++ -like language; in the drift method below,
// "other:m_id != m_id" both m_id values are regular non-static instance members.
// if you want the static behaviour, use the bubble2:m_id approach (bubble2 is the class
// name and access the singleton in the prototype class.)
// Normally you *never* want to use the class name as a name space qualifier because
// you set up the class correctly and initialize via _init_( parameters ). And normally
// a static value is also a constant value, so using a copy is just fine. But if
// multiple instances need to communicate via a singleton static, AND you always use
// the namespace, this is a reasonable place to keep the static.
// Having written all that, I now dislike this particular example because it is using
// a confusing combination of bubble2:m_id and instance values of m_id.
_init_ = Method( {radius, x, y},
m_radius = radius;
this:m_xpos = x; // this: (or nothing) operates on an instance
m_ypos = y;
bubble2:m_id++; // bubble2: operates on the prototype. The next newobject(bubble2(...)) uses the modified prototype
);
distanceBetweenCenters = Method( {other},
/*return*/ Sqrt( (m_xpos - other:m_xpos) ^ 2 + (m_ypos - other:m_ypos) ^ 2 )
);
distanceBetweenEdges = Method( {other}, // negative: overlaps
/*return*/ distanceBetweenCenters( other ) - (m_radius + other:m_radius)
);
drift = Method( {},
// bubbles should pull to 0,0 AND move away from near bubbles
angle = ATan( m_ypos, m_xpos );
radius = Sqrt( m_ypos ^ 2 + m_xpos ^ 2 );
shear = global:twist; // also depends on number of circles
shrink = .99950;
// radius/shear creates a tiny amount of rotation, more on the edges. That rotational
// shearing helps the circles bounce about. /400 is not enough and /100 is too much.
// radius*shrink pulls all the circles to the origin. It is balanced by push, below.
x = Cos( angle + radius / shear ) * radius * shrink;
y = Sin( angle + radius / shear ) * radius * shrink;
// check neighbors
{neighbors, distances} = kdt << kNearestRows( 7, m_id );
tension = 0;
ntension = 0; // calculate a tension, or stress, for contour to use as a color
For( iN = 1, iN <= N Items( neighbors ), iN += 1,
i = neighbors[iN];
other = bubblelist[i];
If( other:m_id != m_id, // <<<<<<<<<<<<<<<< NOT the bubble2:m_id value !!!
dist = distanceBetweenEdges( other );
// if the dist is zero, it is perfect. if the other guy is far away, ignore him.
If( Abs( dist ) < global:bubblesize * 0.8,
tension += dist ^ 2; // this will be a RMS value at the bottom
ntension += 1;
);
If( dist < 0, //push
angle = ATan( m_ypos - other:m_ypos, m_xpos - other:m_xpos );
x += Cos( angle ) * Abs( dist ) ^ .4 * .05;
y += Sin( angle ) * Abs( dist ) ^ .4 * .05;
);//
, //
Beep()
);
);
m_xpos = x;
m_ypos = y;
If( ntension == 0,
ntension = 1;
tension += (global:bubblesize / 2) ^ 2;
);
Sqrt( tension / ntension ); // RMS
);
draw = Method( {},
Transparency( .8 );
Circle( {m_xpos, m_ypos}, m_radius, "FILL" );
Transparency( 1 );
Text( center justified, {m_xpos, m_ypos - m_radius * .2}, Char( m_id ) );
);
);
bubblelist = {};
n = 12; // how many "rings" of hex cells
m = -26 + 21 * n + 3 * (n - 3) ^ 2; // yes, I used JMP to get this formula
For( i = 1, i <= m, i += 1,
Insert Into(
bubblelist,
New Object( bubble2( Random Uniform( global:bubblesize, global:bubblesize ), Random Uniform( -.9, .9 ), Random Uniform( -.9, .9 ) ) )
)
);
// need a table for contour plot, and it will include 100 values in a circle around the hive
ring = 100;
dt = New Table( "tension",
Add Rows( m + ring ),
New Column( "x", Numeric, "Continuous", Format( "Best", 12 ), Set Values( [] ) ),
New Column( "y", Numeric, "Continuous", Format( "Best", 12 ), Set Values( [] ) ),
New Column( "tension", Numeric, "Continuous", Format( "Best", 12 ), Set Values( [] ) )
);
For( i = 1, i <= ring, i += 1,
angle = 2 * Pi() * i / ring;
dt:x[m + i] = 1.25 * Sin( angle );
dt:y[m + i] = 1.25 * Cos( angle );
dt:tension[m + i] = 0;
);
cplot = dt << Contour Plot(
X( :x, :y ),
Y( :tension ),
Show Data Points( 0 ),
Fill Areas( 1 ),
Label Contours( 0 ),
Transform( "Range Normalized" ),
Color Theme( "Green Yellow Red" ),
Specify Contours( Min( 0 ), Max( .01 ), N( 50 ) )
);
Report( cplot )[framebox( 1 )] << Frame Size( 1920, 1080 ) << maximizewindow( 1 ) << backgroundcolor( "black" );
Report( cplot )[framebox( 1 )] << xaxis(
{Format( "Fixed Dec", 12, 3 ), Min( -1.4*1920/1080 ), Max( 1.4*1920/1080 ), Inc( 0.5 ), Label Row(
{Show Major Grid( 0 ), Show Major Labels( 0 ), Show Major Ticks( 0 ), Show Minor Grid( 0 ), Show Minor Labels( 0 ), Show Minor Ticks( 0 )}
)}
);
Report( cplot )[framebox( 1 )] << yaxis(
{Format( "Fixed Dec", 12, 3 ), Min( -1.4 ), Max( 1.4 ), Inc( 0.5 ), Label Row(
{Show Major Grid( 0 ), Show Major Labels( 0 ), Show Major Ticks( 0 ), Show Minor Grid( 0 ), Show Minor Labels( 0 ), Show Minor Ticks( 0 )}
)}
);
// here is the script that makes the bubbles draw
Report( cplot )[framebox( 1 )] << addgraphicsscript(
Fill Color( "black" );
text Color( "white" );
pen Color( rgbcolor(64,64,64) );
For( i = 1, i <= N Items( bubblelist ), i += 1,
bubblelist[i]:draw()
);
hline(0);
vline(0);
);
cplot << onclose(
keepRunning = 0;
Close( dt, nosave );
1;
);
Wait( 0 );
//dir = "$temp\ClassWithStatic" || Char( global:twist ) || "\";
//Delete Directory( dir );
//Create Directory( dir );
//Write( Convert File Path( dir, "windows" ) );
picno = 0;
keepRunning = 1;
While( keepRunning,
xy = J( N Items( bubblelist ), 2, . );
For( i = 1, i <= N Items( bubblelist ), i += 1,
xy[i, 1] = bubblelist[i]:m_xpos;
xy[i, 2] = bubblelist[i]:m_ypos;
);
// the kdtable makes it faster to find near neighbors
kdt = KDTable( xy );
For( i = 1, i <= N Items( bubblelist ), i += 1,
dt:tension[i] = bubblelist[i]:drift();
dt:x[i] = bubblelist[i]:m_xpos;
dt:y[i] = bubblelist[i]:m_ypos;
);
Report( cplot )[framebox( 1 )] << inval << updatewindow;
picno += 1;
// Report( cplot )[framebox( 1 )] << save picture( dir || Char( (picno) + 1e6 ) || ".png" );
Wait( .01 );
);
위의 두 예제는 개체를 나타내는 데이터 테이블의 행과 메서드에 대한 멤버 변수 및 JSL 사용자 함수를 나타내는 열로 쉽게(아마도 더 쉽게) 빌드될 수 있습니다. 특히 서브클래싱 없이 클래스를 사용하면 다른 사람이 JSL의 클래스에 익숙하지 않은 경우 JSL을 따르기가 더 어려워질 수 있습니다.
함수에 대해 말하자면, DefineClass 문서에서도 함수를 언급합니다. 내가 이해할 수 있는 한, 그들은 테이블에 거의 아무것도 가져오지 않으며 아마 피해야 할 것입니다. 나는 클래스의 모든 인스턴스가 아마도 모든 메소드와 모든 멤버 변수의 개별 복사본을 얻고 있다고 생각합니다. Function()을 정의하고 멤버 변수에 저장하면 단일 복사본으로 보다 전역적인 네임스페이스에 있을 수 있는 것을 복사하기 위해 다른 것을 만드는 것입니다. 그러나 단일(또는 극소수) 인스턴스만 있고 해당 매개변수 외에는 아무것도 인식하지 못하는 클래스에 대한 함수가 정말로 필요한 경우 클래스의 함수가 필요한 것일 수 있습니다.
마지막 예제로 이동하여 서브클래싱을 수행하고 마지막 네임스페이스를 살펴보겠습니다. 감독자: , 내가 찾아야만 했던 것(JSL의 주석 참조).
직관적인 예 : 기본 클래스는 차량일 수 있고 하위 클래스(또는 파생 클래스)는 트럭과 자동차입니다. 트럭은 기본 클래스 내비게이션 방법을 주택가 거리를 피할 수 있는 방법으로 대체할 수 있습니다. 자동차는 HOV 차선을 이용할 수 있습니다. 차량 목록은 A에서 B로 이동하라는 지시를 받았을 때 각각 올바른 작업을 수행합니다.
Define Class에는 다음과 같은 흥미로운 주장이 있습니다. 기본 클래스(...) . 아래 예에서 모양 기본 클래스가 될 것이며 정사각형 그리고 원 모양에서 파생됩니다. 예제는 사각형과 원의 목록을 만들고 표시합니다.
two squares, two circles, two outlined, two filled사각형 2개, 원 2개, 윤곽선 2개, 채움 2개
다음 설명은 시행 착오를 기반으로 합니다. 어떻게 작동할지 예측하는 데 도움이 되는 모델이 되기에 충분히 정확하다고 생각합니다.
뭐야 감독자: ?
파생 클래스가 생성되면 JMP는 해당 클래스가 끝날 때까지 실행됩니다. 기본 클래스 기본 클래스를 먼저 만들고 자체 네임스페이스에서 만들어 맨 위로 돌아가 작동합니다. 네임스페이스는 내부적으로 서로 연결되어 파생 클래스가 자체 네임스페이스를 찾은 다음 변수를 찾을 때까지 네임스페이스 체인을 따라 기본 클래스까지 내려감으로써 멤버 변수를 참조할 수 있습니다. 그만큼 감독자 : 네임스페이스는 현재 네임스페이스를 보지 않고 네임스페이스 체인에서 한 번 건너뛰는 것을 의미합니다. 그렇기 때문에 아래 JSL은 "필요하지 않은 경우 기본 메서드를 호출하기 위해 super:를 사용하지 마십시오"라고 말합니다. 기본 메서드는 파생된 네임스페이스에 액세스할 수 없으므로 파생된 함수를 호출할 수 없습니다.
다중 상속: "인터페이스"를 사용하고 중복 이름을 피하는 경우 작동할 수 있습니다. 행운을 빌어요. 형제 기본 클래스가 위 모델의 네임스페이스 체인에 맞는 위치가 확실하지 않습니다.
// demonstrates JMP class inheritance and overriding a method
// and calling the super class. A circle and a square class
// are derived from a shape class. Explains when to NOT use super:.
//
// I found super: in https://github.com/sassoftware/jsl-hamcrest/blob/master/Source/Core/Matchers/EqualTo.jsl
// it isn't documented anywhere else, but works great for calling base class _init_
// Also, https://github.com/sassoftware/jsl-hamcrest/blob/master/Source/Core/Utils.jsl
// shows a "self" implementation idea. This is a bad idea because it creates a circular reference
// that must be cleared before the object is lost/deleted...or it will leak.
// avoid making members and methods in base and derived classes with the same name.
// _init_, _to string_, _show_ are exceptions, but they must not try to use a derived
// class member or method. (you would not normally want to, so no problem.)
//
// avoid needless upcast (super:); it cripples the base class because there is no downcast or
// virtual mechanism. Without the upcast, a baseclass function runs with access to the
// derived class members and methods. (see square's draw method calling docolor calling record.)
//
// it appears that the derived chain is searched *after* the current class; in a two class
// (base,derived) example that inverts the search order for members and methods when a
// derived class uses "super:" to call a base class method. If the base class calls a "virtual"
// function that exists in both base and derived, it won't get the derived one if "super:" was
// used but will if no scope is used. You only need "super:" typically when you want to call
// the base class method from an overridden method of the same name. If the base class method
// isn't calling back to derived via a virtual, everything is good.
// deep details
//
// the output shows lines like this:
// record square=square(shape=(s= x=30 y=30 r=5 s=4 c=yellow f=1))
// record circle=circle(shape=(s= x=30 y=60 r=10 s=99 c=green f=0))
//
// the square and the circle both get the right answer via different
// paths. Because of way draw() is overridden by square and not by circle,
// the initial call, objects[window:i] << draw(), is calling either a
// derived member or a base member. In both cases, "this" is for the
// derived member. in square's draw(), I made an error, now commented
// out: /*super:*/docolor(), that caused docolor to run with "this"
// for the base class, not the derived class. docolor then calls record().
// all three classes have record() members. The intent is to override the
// base class version ("never seen"). The error caused the base class
// version to run for square because "this" of docolor() was for the base class.
Define Class( "shape", // base class for both shapes
m_Xcenter = .;
m_Ycenter = .;
m_radius = .;
m_sides = .;
m_color = .;
m_filled = .;
_init_ = Method( {x, y, radius, sides, color, fill},
m_Xcenter = x;
m_Ycenter = y;
m_radius = radius;
m_sides = sides;
m_color = color;
m_filled = fill;
);
_to string_ = Method( {},
"shape=(s=" ||
" x=" || Char( m_Xcenter ) || " y=" || Char( m_Ycenter ) ||
" r=" || Char( m_radius ) || " s=" || Char( m_sides ) ||
" c=" || Char( m_color ) || " f=" || Char( m_filled ) || ")"
);
_show_ = _to string_;
// the following should NOT ever get called because square and circle override it
// try changing square to call super:docolor and then you'll see this
record=method({},show("never seen, overridden by square and circle"));
// both shapes understand filled vs outlined
// see note in square:draw method about calling docolor without super:
docolor = Method( {},
this:record(); // this: doesn't change anything,
If( this:m_filled, // it is mostly for disambiguating
Fill Color( /*this:*/m_color );// parameter of same name
, //
Pen Color( this:m_color )
)
);
// the base class has a draw method that circle uses;
// square provides an override because this draws a
// diamond-oriented square
draw = Method( {},
docolor();
p = J( m_sides, 3, 2 );//2==draw
p[1, 3] = 1;//1==move
p[m_sides, 3] = -2;//-2==draw and close
For( i = 1, i <= m_sides, i += 1,
p[i, 1] = m_Xcenter + m_radius * Cos( 2 * Pi() * i / m_sides );
p[i, 2] = m_Ycenter + m_radius * Sin( 2 * Pi() * i / m_sides );
);
Path( p, m_filled );
);
);
Define Class( "circle", baseclass( shape ),
_init_ = Method( {x, y, radius, color, fill},
super:_init_( x, y, radius, 99/*sides*/, color, fill )
);
_to string_ = Method( {},
"circle(" || super:_tostring_() || ")"
);
_show_ = _to string_;
record=method({},write("\!nrecord circle=",_show_()));
// circle has no override for draw()
);
Define Class( "square", baseclass( shape ),
_init_ = Method( {x, y, radius, color, fill},
super:_init_( x, y, radius, 4/*sides*/, color, fill )
);
_to string_ = Method( {},
"square(" || super:_tostring_() || ")"
);
_show_ = _to string_;
record=method({},write("\!nrecord square=",_show_()));
// square overrides the base class draw
draw = Method( {},
/*super:*/docolor();// don't up-cast, docolor can't down-cast and gets base class record()
Rect(
m_Xcenter - m_radius,
m_Ycenter - m_radius,
m_Xcenter + m_radius,
m_Ycenter + m_radius,
m_filled
);
);
);
objects = {};
Insert Into( objects, New Object( square( 30, 30, 5, "yellow", 1 ) ) );
Insert Into( objects, New Object( Circle( 30, 60, 10, "green", 0 ) ) );
Insert Into( objects, New Object( square( 60, 30, 15, "blue", 0 ) ) );
Insert Into( objects, New Object( Circle( 60, 60, 20, "red", 1 ) ) );
New Window( "objects",
gb = Graph Box( framesize( 500, 500 ),
For( window:i = 1, window:i <= N Items( objects ), window:i += 1,
//Show( objects[i] );
objects[window:i] << draw(); // uses the base class or the derived class draw
)
)
);
//stop();
// animate the color of object 4, the big red circle
For( i = 0, i <= 1, i += (1 / 256), //show(i);
objects[4]:m_color = HLS Color( i, .5, 1 );
gb << inval << updatewindow;
Wait( 0 );
);
는 어때 이것 ?
C++에는 개체가 자신을 참조하는 데 때때로 필요한 "this"(다른 언어에서는 "self" 및 "me" 사용)라는 값이 있습니다. 다음과 같지 않음: 네임스페이스 접두사. 나는 JSL 클래스가 클래스 내에서 "this"를 제공한다고 생각하지 않으며 다음과 같이 만들고 싶을 수도 있습니다.
x = newObject(myClass(17));
x::self = x;
또는 그에 가까운 것. 그런 다음 myClass 메서드는 "self"를 사용하여 복제와 같은 클래스 인스턴스가 필요한 작업을 수행할 수 있습니다.
Scripting index showing messages that can be sent to a class instance클래스 인스턴스로 보낼 수 있는 메시지를 보여주는 스크립팅 색인
클래스 인스턴스를 포함하는 클래스 인스턴스에 멤버 변수를 유지하면 메모리 누수가 발생할 수 있습니다. 이것은 우리를 새로운 주제로 인도합니다. 사실 주제입니다.
인스턴스는 언제 삭제됩니까?
인스턴스에 대한 참조가 없으면 인스턴스가 삭제됩니다. 위 섹션에서 인스턴스 내부의 "self" 참조는 인스턴스가 삭제되는 것을 방지합니다. 인스턴스에 대한 모든 핸들을 잃어버린 경우에도 . JMP를 닫는 것 외에는 정리할 방법이 없습니다.
인스턴스는 언제 복사됩니까?
가장 중요한 부분은 <이는 인스턴스가 참조로 전달됨을 의미합니다.예이! JMP가 행렬 인수의 복사본을 매개변수 값으로 만들고 다른 복사본을 반환하도록 하는 대신 큰 행렬을 래핑하고 클래스의 인스턴스를 사용자 함수에 전달하는 간단한 클래스를 만드는 것이 덜 어색합니다.
