Node.jsのJavaScriptメソッドのソースコード（hasOwnPropertyなど）はどこで確認できますか？

Question

インタビューのためにJavaScriptアルゴリズムとBig Oを勉強しています。私は、Object.prototype.hasOwnPropertyとArray.prototype.mapのようなビルトインメソッドのランタイムを知っていることが重要であると言われました。

node.jsでこれらの関数のソースコードを表示する簡単な方法は何ですか？私はnode.jsのローカルコピーを持っており、テキストエディタでこれらのメソッドを検索しようとしましたが、思ったほど単純ではありません。

Answer 1

Object.prototype.hasOwnProperty（）

ビューのJavascriptのインタビューの観点から、私はあなただけの完全obj.hasOwnProperty()は、それがV8の内部に実装だではないか、Javascriptのレベルで何をするか理解する必要があると思うだろう。

はそれを行うには、あなたは完全にこの小さなスニペットを理解する必要があります。

function MyConstructor() { 
    this.methodB = function() {} 
} 

MyConstructor.prototype = { 
    methodA: function() {} 
}; 

var o = new MyConstructor(); 
log(o.hasOwnProperty("methodA")); // false 
log(o.hasOwnProperty("methodB")); // true 

o.methodA = function() {};   // assign "own" property, overrides prototype 
log(o.hasOwnProperty("methodA")); // true 

.hasOwnProperty()のみオブジェクト自体にではなく、プロトタイプチェーン上に見えるためです。したがって、プロトタイプチェーン上にのみ存在するプロパティまたは存在しないプロパティは、falseを返し、オブジェクト上に直接存在するプロパティはtrueを返します。

---

Array.prototype.map（）

Array.prototype.map()用のJavascriptでポリフィルは、それが動作します正確にどのようにあなたが表示されますhere on MDNです。もちろん、Githubリポジトリで上記と同じタイプの検索を行い、必要に応じて.map()の実装を見つけることもできます。

Array.prototype.map()本当に簡単です。配列全体を繰り返し、配列内の各項目の関数を呼び出します。その関数の各戻り値は、.map()への呼び出しから返される新しい配列を構築するために使用されます。したがって、概念的には、元の配列の各要素に対してある変換関数を呼び出すことによって、ある配列を別の配列に「マップ」するために使用されます。最も単純な化身で

、あなたは、配列の各要素に 1を追加します。

var origArray = [1,2,3]; 

var newArray = origArray.map(function(item, index, array) { 
    return item + 1; 
}); 

console.log(newArray); // [2,3,4] 

---

実際のV8のソースコード：あなたは本当にそれが実装されているか確認したい場合は

V8の内部には、コードスニペットと関連する実際のコードファイルへのリンクがあります。ご覧のように、ほとんどがC++であり、理解するためには、オブジェクトがメモリ内でどのように構造化されているのか、内部でV8でどのようなC++メソッドが使われているのかを理解する必要があります。これは、V8特有のものであり、一般的なJavascriptの知識ではありません。

関連するソースファイルへのリンクも含まれています。そのファイル内の他のコンテキストを表示するには、そのリンクをクリックしてください。

v8.hにおいて：

V8_DEPRECATED("Use maybe version", bool HasOwnProperty(Local<String> key)); 
V8_WARN_UNUSED_RESULT Maybe<bool> HasOwnProperty(Local<Context> context, Local<Name> key); 

api.ccにおいて：

Maybe<bool> v8::Object::HasOwnProperty(Local<Context> context, 
             Local<Name> key) { 
    PREPARE_FOR_EXECUTION_PRIMITIVE(context, "v8::Object::HasOwnProperty()", 
            bool); 
    auto self = Utils::OpenHandle(this); 
    auto key_val = Utils::OpenHandle(*key); 
    auto result = i::JSReceiver::HasOwnProperty(self, key_val); 
    has_pending_exception = result.IsNothing(); 
    RETURN_ON_FAILED_EXECUTION_PRIMITIVE(bool); 
    return result; 
} 

bool v8::Object::HasOwnProperty(Local<String> key) { 
    auto context = ContextFromHeapObject(Utils::OpenHandle(this)); 
    return HasOwnProperty(context, key).FromMaybe(false); 
} 

v8natives.jsにおいて：

// ES6 7.3.11 
function ObjectHasOwnProperty(value) { 
    var name = TO_NAME(value); 
    var object = TO_OBJECT(this); 
    return %HasOwnProperty(object, name); 
} 

objects-inl.hで：

で

：

static Object* HasOwnPropertyImplementation(Isolate* isolate, 
              Handle<JSObject> object, 
              Handle<Name> key) { 
    Maybe<bool> maybe = JSReceiver::HasOwnProperty(object, key); 
    if (!maybe.IsJust()) return isolate->heap()->exception(); 
    if (maybe.FromJust()) return isolate->heap()->true_value(); 
    // Handle hidden prototypes. If there's a hidden prototype above this thing 
    // then we have to check it for properties, because they are supposed to 
    // look like they are on this object. 
    if (object->map()->has_hidden_prototype()) { 
    PrototypeIterator iter(isolate, object); 
    DCHECK(!iter.IsAtEnd()); 

    // TODO(verwaest): The recursion is not necessary for keys that are array 
    // indices. Removing this. 
    // Casting to JSObject is fine because JSProxies are never used as 
    // hidden prototypes. 
    return HasOwnPropertyImplementation(
     isolate, PrototypeIterator::GetCurrent<JSObject>(iter), key); 
    } 
    RETURN_FAILURE_IF_SCHEDULED_EXCEPTION(isolate); 
    return isolate->heap()->false_value(); 
} 


RUNTIME_FUNCTION(Runtime_HasOwnProperty) { 
    HandleScope scope(isolate); 
    DCHECK(args.length() == 2); 
    CONVERT_ARG_HANDLE_CHECKED(Object, object, 0) 
    CONVERT_ARG_HANDLE_CHECKED(Name, key, 1); 

    uint32_t index; 
    const bool key_is_array_index = key->AsArrayIndex(&index); 

    // Only JS objects can have properties. 
    if (object->IsJSObject()) { 
    Handle<JSObject> js_obj = Handle<JSObject>::cast(object); 
    // Fast case: either the key is a real named property or it is not 
    // an array index and there are no interceptors or hidden 
    // prototypes. 
    // TODO(jkummerow): Make JSReceiver::HasOwnProperty fast enough to 
    // handle all cases directly (without this custom fast path). 
    Maybe<bool> maybe = Nothing<bool>(); 
    if (key_is_array_index) { 
     LookupIterator it(js_obj->GetIsolate(), js_obj, index, 
         LookupIterator::HIDDEN); 
     maybe = JSReceiver::HasProperty(&it); 
    } else { 
     maybe = JSObject::HasRealNamedProperty(js_obj, key); 
    } 
    if (!maybe.IsJust()) return isolate->heap()->exception(); 
    DCHECK(!isolate->has_pending_exception()); 
    if (maybe.FromJust()) { 
     return isolate->heap()->true_value(); 
    } 
    Map* map = js_obj->map(); 
    if (!key_is_array_index && !map->has_named_interceptor() && 
     !map->has_hidden_prototype()) { 
     return isolate->heap()->false_value(); 
    } 
    // Slow case. 
    return HasOwnPropertyImplementation(isolate, Handle<JSObject>(js_obj), 
             Handle<Name>(key)); 
    } else if (object->IsString() && key_is_array_index) { 
    // Well, there is one exception: Handle [] on strings. 
    Handle<String> string = Handle<String>::cast(object); 
    if (index < static_cast<uint32_t>(string->length())) { 
     return isolate->heap()->true_value(); 
    } 
    } else if (object->IsJSProxy()) { 
    Maybe<bool> result = 
     JSReceiver::HasOwnProperty(Handle<JSProxy>::cast(object), key); 
    if (!result.IsJust()) return isolate->heap()->exception(); 
    return isolate->heap()->ToBoolean(result.FromJust()); 
    } 
    return isolate->heap()->false_value(); 
} 

これはnode.js Github repositoryです。何を検索するのか分かっていて、すべての検索ヒットを忍耐するために十分な忍耐力があれば、一般的に必要なものを見つけることができます。 Githubで検索することについての不幸なことは、検索からすべてのテストサブディレクトリを削除する方法が見つからないため、実際の実装コードではなく、テストヒットの95％で終わることです。しかし、十分な持続性があれば、最終的に必要なものを見つけることができます。