我不敢拉肚子，因为队里没有公厕。老式茅斯已经是不想去了：茅斯桥雨天打滑还有射屎的时候经常被粪和生命之源溅到，是小时候的梦魇。拉尿于我是不妨碍的，建强哥屋往前150米左边有一处荒田，无论白天晚上都可以去荒田小便；女客们却很不相宜，晚上也就罢了，白天没法在荒田小便的，荒田对面竹林呢晚上又黑又暗，丧事期间但凡刮阵阴风，再胆大的客人也不敢去了。
蔷哥说志英和我大老远不容易，给了啊主客房的钥匙，但是我们还是没好意思麻烦他们，后半夜熬不住就去车上炜着了; 四八舅匆匆赶回，打鼓说书刚听完眼皮子就打架；志勇家在洋桥，和珍姨娘和贺贤在祠堂把着靠椅打了一夜盹; 健表叔在下屋也没有亲戚，他挺头在祠堂烤了一夜火，不愧是做过金刚和丈夫(抬棺轿夫)的，我就算是年轻火力最猛的时候也不敢熬一晚上呢，所以真佩服健表叔啊。
祠堂的厨房也挺尴尬的，上午我在厨房当火头，发现房里只有两口灶，下午我回去的时候碰到力哥说队里的锅坏了一口，国军哥十万火急去洋桥买锅呢
来书又有云：“人情机诈百出，御之以不疑，往往为所欺；觉则自入于逆、億。夫逆诈，即诈也；億不信，即非信也；为人欺，又非觉也。不逆、不億而常先觉，其惟良知莹彻乎(想做到不诈且先觉他人之诈，除非良知莹彻)？然而出入毫忽之间，背觉(未能先觉)合诈者多矣。”
“不逆不億而先觉”，此孔子因当时人专以逆诈、億不信为心，而自陷于诈与不信，又有不逆、不億者，然不知致良知之功，而往往又为人所欺诈，故有是言，非教人以是存心而专欲先觉人之诈与不信也（孔子说的先觉是教人致良知之功，而非刻意去防人）。以是存心，即是后世猜忌险薄者之事；而只此一念，已不可与入尧舜之道矣。不逆、不億而为人所欺者，尚亦不失为善，但不如能致其良知而自然先觉者之尤为贤耳。崇一谓“其惟良知莹彻”者，盖已得其旨矣。然亦颖悟所及，恐未实际也。盖良知之在人心，亘万古、塞宇宙而无不同。不虑而知，“恒易以知险”；不学而能，“恒简以知阻”。“先天而天不违，天且不违，而况于人乎？况于鬼神乎？”夫谓背觉合诈者，是虽不逆人而或未能无自欺也，虽不億人而或未能果自信也，是或常有求先觉之心，而未能常自觉也。常有求先觉之心，即已流于逆、億而足以自蔽其良知矣，此背觉合诈之所以未免也（刻意求先觉，已流于逆、億而足以自蔽其良知，这就是毫忽之间背觉合诈的原因）。君子学以为己，未尝虞人之欺己也，恒不自欺其良知而已；未尝虞人之不信己也，恒自信其良知而已；未尝求先觉人之诈与不信也，恒务自觉其良知而已。是故不欺则良知无所伪而诚，诚则明矣；自信则良知无所惑而明，明则诚矣。明、诚相生，是故良知常觉、常照。常觉、常照，则如明镜之悬，而物之来者自不能遁其妍媸矣。何者？不欺而诚，则无所容其欺，苟有欺焉而觉矣；自信而明，则无所容其不信，苟不信焉而觉矣。是谓易以知险、简以知阻，子思所谓“至诚如神”、“可以前知”者也。然子思谓“如神”、谓“可以前知”，犹二而言之，是盖推言思诚者之功效，是犹为不能先觉者说也。若就至诚而言，则至诚之妙用即谓之“神”，不必言“如神”；至诚则“无知而无不知”，不必言“可以前知”矣。
崇一: 想做到不诈且先觉他人之诈，除非良知莹彻;但是毫忽之间，很多人反而背觉(未能先觉)合诈了。 阳明: 孔子说的先觉是教人致良知之功，而非刻意去防人 阳明: 刻意求先觉，已流于逆、億而足以自蔽其良知，这就是毫忽之间背觉合诈的原因 阳明: 不欺则良知无所伪而诚，诚则明矣；自信则良知无所惑而明，明则诚矣。明、诚相生，是故良知常觉、常照。 阳明: 自信而明，则无所容其不信，苟不信焉而觉矣。
A 32-bit signed value can be treated as having a binary point immediately after its sign bit. This is equivalent to dividing its signed integer value by 231, so that it can now represent numbers from –1 to (1 – 2–31). When a 32-bit value is used to represent a fractional number in this fashion, it is known as a Q31 number.
Saturated additions, subtractions, and doublings can be performed on Q31 numbers using the same instructions as are used for saturated integer arithmetic, since everything is simply scaled down by a factor of 2–31.
If two Q15 numbers are multiplied together as integers, the resulting integer needs to be scaled down by a factor of 2–15 × 2–15 == 2–30. For example, multiplying the Q15 number 0x8000 (representing –1) by itself using an integer multiplication instruction yields the value 0x40000000, which is 230 times the desired result of +1.
This means that the result of the integer multiplication instruction is not quite in Q31 form. To get it into Q31 form, it must be doubled, so that the required scaling factor becomes 2–31. Furthermore, it is possible that the doubling will cause integer overflow, so the result should in fact be doubled with saturation. In particular, the result 0x40000000 from the multiplication of 0x8000 by itself should be doubled with saturation to produce 0x7FFFFFFF (the closest possible Q31 number to the correct mathematical result of –1 × –1 == +1). If it were doubled without saturation, it would instead produce 0x80000000, which is the Q31 representation of –1.
To implement a saturated Q15 × Q15 --> Q31 multiplication, therefore, an integer multiply instruction should be followed by a saturated integer doubling. The latter can be performed by a QADD instruction adding the multiply result to itself.
A global Environment Record is used to represent the outer most scope that is shared by all of the ECMAScript Script elements that are processed in a common realm. A global Environment Record provides the bindings for built-in globals, properties of the global object(FunctionDeclaration or VariableStatement), and for all top-level declarations(the let and const declarations) that occur within a Script.
A global Environment Record is logically a single record but it is specified as a composite encapsulating of object Environment Record([[ObjectRecord]]) and a declarative Environment Record([[DeclarativeRecord]]).
The object Environment Record has as its base object the global object of the associated Realm Record. This global object is the value returned by the global Environment Record's GetThisBinding concrete method:
Let envRec be the global Environment Record for which the method was invoked. Return envRec.[[GlobalThisValue]] zxxu: according to ecma, Regular object Environment Records do not provide a this binding, so global Environment Record has a [[GlobalThisValue]] field
The object Environment Record contains the bindings for all built-in globals and all bindings introduced by a FunctionDeclaration or VariableStatement contained in global code. The bindings for all other ECMAScript declarations(the let and const declarations) in global code are contained in the declarative Environment Record component.
Properties may exist upon a global object that were directly created rather than being declared using a var or function declaration. so global Environment Record also has a field [[VarNames]] for string names bound by FunctionDeclaration or VariableDeclaration.
note If IsSuperReference(V), GetThisValue(V) returns the thisValue component of the reference V; else returns GetBase(V).
abstract operation O.[[Get]](P, Receiver) works as:
above all
k=3, s=123, n=0
n=k1=3, k2=1, s=123.4
k=3, s=423, n=-1 ==> k1=n=-1,pow(10,k1-1)=0.04
k=3, s=423, n=5 ==> pow(10, n-1) = 4
mySymbol = Symbol( "my symbol" ) // Object() performs a type conversion when called as a function rather than as a constructor. mySymObj = Object(mySymbol) console.log(mySymObj.toString()) // Symbol(my symbol)
function anInstanceOfFunction(data)
{
this.data = data;
}
thisArgument = {"data" : null};
// all instances of Function(function definitions or dynamical functions by `new Function`) has
// their [[prototype]] chained to the Function constructor's prototype property(Function.prototype)
anInstanceOfFunction.call(thisArgument, "dat");
console.log(thisArgument.data);
note Function.prototype itself is a function object(to ensure compatibility with es2015), which returns undefined when called; but the call here is `Function.prototype.` instead of `Function.prototype(`
calleeContext = {
"Function" : F,
"LexicalEnvironment" : new NewFunctionEnvironment(F),
}
calleeContext.VariableEnvironment = calleeContext.LexicalEnvironment
Push calleeContext onto the execution context stack
return calleeContext
const person = {
getFullName: function () {
return this.firstName + " " + this.lastName;
}
}
const thisPerson = {
firstName : "John",
lastName : "Xu",
}
let getFullName = person.getFullName.bind(thisPerson);
console.log( getFullName() )
return {
[[BoundTargetFunction]]: targetFunction,
[[BoundThis]]: boundThis,
[[BoundArguments]]: boundArgs,
[[Prototype]]:targetFunction.[[Prototype]],
}
base_obj = {
"constructor" : my_constructor,
}
function my_constr_stub()
{
console.log("in constructor stub:new.target=" + new.target);//undefined
}
function my_constructor()
{
console.log("in constructor:new.target=" + new.target);// function my_constructor(){...
my_constr_stub();
}
my_constructor.prototype = base_obj;
new my_constructor()
The second argument is the object to which the new operator was initially applied. For example, in following code, the new operator is initially applied to the Square object:
class Rectangle {
constructor(height, width) {
console.log("in Rectangle:new.target=" + new.target);
this.name = 'Rectangle';
this.height = height;
this.width = width;
}
}
class Square extends Rectangle {
constructor(length) {
console.log("in Square:new.target=" + new.target);
super(length, length);
this.name = 'Square';
}
}
aS = new Square(2);
console.log(
"name=" + aS.name +
";height=" + aS.height
);
factit = function factorial(n) {
console.log(n)
if (n < 2) {
return 1;
}
return n * factorial(n - 1);
}
non_recursive = function(){}
/*
can't visit factorial here:
as is indicated in `Runtime Semantics: Evaluation` of NAMED function expression,
we will NewDeclarativeEnvironment(scope) as a middle env to recv factorial
from ecma:
The BindingIdentifier in a FunctionExpression can be referenced
from inside the FunctionExpression's
FunctionBody to allow the function to call itself recursively.
However, unlike in a FunctionDeclaration, the BindingIdentifier in
a FunctionExpression cannot be referenced from and does
not affect the scope enclosing the FunctionExpression.
*/
Return a new empty List.
Let declarations be TopLevelVarScopedDeclarations of StatementList.
Append to declarations the elements of the TopLevelVarScopedDeclarations of StatementListItem.
Return declarations.
if is function Declaration, return a list contains the Declaration// function is not taken as Lex but top level Var!
LabelledStatement : LabelIdentifier : LabelledItem
Return the TopLevelVarScopedDeclarations of LabelledItem.
LabelledItem : Statement
// recursive to the last non-labelled Statement
If Statement is Statement : LabelledStatement , return TopLevelVarScopedDeclarations of Statement
Return VarScopedDeclarations of Statement.
not documented in ecma documents
Return a new empty List.
Let declarations be TopLevelLexicallyScopedDeclarations of StatementList.
Append to declarations the elements of the TopLevelLexicallyScopedDeclarations of StatementListItem.
Return declarations.
Return a new empty List.//VariableStatement contribute to Var instead of Lex
if Declaration is `let ` or `const `, return a new List containing Declaration;
else Return a new empty List// TopLevel functions are taken as Var instead
Return a new empty List
not documented in ecma documents
Let declarations be LexicallyScopedDeclarations of StatementList.
Append to declarations the elements of the LexicallyScopedDeclarations of StatementListItem.
Return declarations.
Return a new List containing the Declaration
Return the TopLevelLexicallyScopedDeclarations of StatementList.
Return a new List containing FunctionDeclaration.
not documented in ecma documents
`catch ( CatchParameter ) Block` is not mentioned, but according to "Runtime Semantics: CatchClauseEvaluation", CatchParameter should be Lexically Declared
Return a new empty List.
Let declarations be VarScopedDeclarations of StatementList.
Append to declarations the elements of the VarScopedDeclarations of StatementListItem.
Return declarations.
Return a new empty List// `let ` or `const ` Declaration is Lex, funct decl is top Var
Return a new List contains all VariableDeclaration
Return the TopLevelVarScopedDeclarations of StatementList.
if/while/for/with/switch/label/try Statement, return a new List contains all VariableDeclaration of the sub(s)
for the case of `for(var `, the new List is pre-feed.
note in `catch ( CatchParameter ) Block`, CatchParameter is not included.
note in label Statement, `LabelledItem : FunctionDeclaration` Return a new empty List.
not documented in ecma documents
function outer_func()
{
{{
var var01 = "var01";
let innerLet = "innerLet";// const innerCst = "innerCst";
function inner_func()
{
alert("inner_func");
}
}}
// var01 is accessible here
// it's an early error to access innerLet here
inner_func();
}
outer_func();
return GetThisEnvironment().[[FunctionObject]].[[GetPrototypeOf]]()
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/super : super([arguments]) // calls the parent constructor.
There are following basic rules of semicolon insertion:
However, there is an additional overriding condition on the preceding rules: a semicolon is never inserted automatically if the semicolon would then be parsed as an empty statement or if that semicolon would become one of the two semicolons in the header of a for-statement
The source
return a + bis transformed by automatic semicolon insertion into the following:
return; a + b;
according to rule 2 and `return [no LineTerminator here] Expression`
IdentifierName can be devided into ReservedWord and Identifier.
A keyword is a token that matches IdentifierName, but also has a syntactic use.
Many keywords are reserved words, but some are reserved only in certain contexts. contextual keywords(await and yield) belong to ReservedWord but sometimes can be used as identifiers.
Followings belong to Identifier but not intepreted as so under certain syntactic productions: