精华内容
下载资源
问答
  • jQuery对象默认都有个0索引, s为jQuery对象 s[0]为Dom元素 可以用dom所有属性和方法 可以根据length属性判断一共包含有多少个Dom元素对象。 取对象用:s[0],s[1],s[2]…… #id 根据给定ID匹配一个元素。$(“#...
  • $代表的是jQuery这个对象 https://www.jb51.net/article/53391.htm jQuery 对象是通过 jQuery 包装DOM 对象后产生的对象。jQuery 对象是 jQuery 独有,其可以使用 jQuery 里方法,但是不能使用 DOM 方法;例如...

    $代表的是jQuery这个对象

    https://www.jb51.net/article/53391.htm
    jQuery 对象是通过 jQuery 包装DOM 对象后产生的对象。jQuery 对象是 jQuery 独有的,其可以使用 jQuery 里的方法,但是不能使用 DOM 的方法;例如: $("#img").attr(“src”,“test.jpg”); 这里的 $("#img")就是 jQuery 对象。

    DOM对象就是Javascript 固有的一些对象操作。DOM 对象能使用Javascript 固有的方法,但是不能使用 jQuery 里的方法。例如:document.getElementById(“img”).src = “test.jpg";这里的document.getElementById(“img”) 就是DOM 对象。

    $("#img").attr(“src”,“test.jpg”); 和 document.getElementById(“img”).src = “test.jpg”; 是等价的,是正确的,但是 $("#img").src = “test.jpg” ;或者 document.getElementById(“img”).attr(“src”,“test.jpg”); 都是错误的。

    再说一个例子,就是this, 在写 jQuery 时经常这样写: this.attr(“src”,“test.jpg”);可是就是出错,其实this 是DOM对象,而.attr(“src”,“test.jpg”) 是 jQuery 方法,所以出错了。要解决这个问题就要将 DOM对象转换成 jQuery 对象,例如 $(this).attr(“src”,“test.jpg”);

    1. DOM 对象转成 jQuery 对象

    对于已经是一个 DOM 对象,只需要用 $() 把DOM对象包装起来,就可以获得一个 jQuery 对象了,$(DOM 对象) 注: var是定义变量

    如:

    var v = document.getElementById(“v”); //DOM对象
    var $v = $(v); //jQuery 对象
    转换后,就可以任意使用 jQuery 的方法。

    1. jQuery 对象转成 DOM 对象

    两种转换方式讲一个 jQuery 对象转换成 DOM 对象: [index] 和 .get(index);

    (1) jQuery 对象是一个数据对象,可以通过 [index] 的方法,来得到相应的 DOM 对象。

    如:

    var $v = $("#v"); //jQuery 对象
    var v = $v[0]; //DOM 对象
    alert(v.checked); //检测这个checkbox是否被选中
    (2) jQuery 本身提供,通过.get(index) 方法得到相应的 DOM 对象

    如:

    var $v = $("#v"); //jQuery 对象
    var v = $v.get(0); //DOM对象 ( $v.get()[0] 也可以 )
    alert(v.checked); //检测这个 checkbox 是否被选中
    通过以上方法,可以任意的相互转换 jQuery 对象和 DOM 对象,需要再强调的是: DOM 对象才能使用DOM 中的方法,jQuery 对象是不可以使用DOM中的方法。

    https://blog.csdn.net/qq_36273128/article/details/52932841

    8jquery组件封装参考下面的
    注意对参数的预处理
    https://www.jianshu.com/p/1b55c475b165

    通过$.extend()来扩展jQuery 这个意思是单独的一个方法,不绑定在html元素上,直接把方法放在$对象里面
    通过$.fn 向jQuery添加新的方法 这个指的是绑定在元素上,设置选择器,这里面的fn就是选择的元素
    通过$.widget()应用jQuery UI的部件工厂方式创建

    $(function () {
    >     $.fn.插件名称 = function (options) {
    >         var defaults = {			这里在设置一个default对象,用来下文使用,里面的值代表函数中要用的
    >             Event : "click", //触发响应事件
    >             msg : "Holle word!" //显示内容
    >         };
    >         var options = $.extend(defaults, options);   利用extend来将ortions传入的数据覆盖defaults原有的,如果没有则添加
    >         var $this = $(this); //当然响应事件对象  这里的前一个this是jquery对象,后一个是dom对象就是捕获的组件,比如<p>等,用this.的方法来获得和更改组件的值或者属性,转换方式就是\$()包起来
    >         //功能代码部分
    >         //绑定事件
    >         $this.live(options.Event, function (e) {      live方法是用来绑定时间的方法,第一个为激活的事件如点击click,
    >                                                                         第二个为  执行的函数      这里的下面几行有解释是event传进来的
    >                                                                         参数,比如鼠标事件的坐标信息,key事件的按键信息,给函数用,可以不写                 
    >             alert(options.msg);
    >         });
    >     } });
    

    调用时按照格式输入参数

    $(function () {
        //绑定元素事件
        $("#test").插件名称({
            Event : "click", //触发响应事件
            msg : "插件原来就是这么简单!" //显示内容
        });
    });
    

    布局

    <input type = "button" id = "test" value = "这是一个简单的插件调用" /  >
    

    对e的解释

    ("body").on("click",function(e){
        var ele = e.target
    });
    

    e代表event,是jQuery会传进来的第一个参数
    意思是 如果后面需要获取操作的信息 就要加e 如果不需要,只是完成一个事件,就可以不加e

    https://blog.csdn.net/u598975767/article/details/75543012

    https://www.cnblogs.com/landeanfen/p/5124542.html 这个是第二个方法通常也是使用这个

    第一步:要想封装自己的jq插件,要先了解jquery插件运行机制。jQuery使用无new的构造方式,直接$(’ ')进行构造,相当于new jQuery()。看下面例子。

    jQuery将jQuery.prototype赋值给jQuery.prototype.init的prototype作为中转站,最终return出了一个jQuery实例。将上述代码写在一个自执行函数内(形成私有作用域,避免命名空间污染),就构成了jQuery的核心框架。

    第二步: jquery的两种使用方法 $.function() 和 $(“selector”);

    1 $.function() 是在jquery原型对象设置的方法。我们可以通过 $.fn.extend()去扩展。例如:

    $.fn.extend({
    getMax:function(a,b){ //getMax 自定义方法。3
    var result=a>b?a:b;
    console.log(result);
    }
    });
    $(“input”).getMax(1,2); //使用方法
    2 (&quot;selector&quot;)jquery(&quot;selector&quot;)是在jquery对象上设置的方法。我们可以通过.extend()去扩展。例如:

    $.extend({
    print1:function(name){ //print1是自己定义的函数名字,括号中的name是参数
    console.log(name)
    }
    });
    $.print1(“222”) ; //使用方法
    所以我们的扩展插架也有两种方式。

    第一种:在jQuery对象上添加了一个静态方法。所以我们调用通过.extend().extend()添加的函数时直接通过符号调用(.myfunction()DOM(.myfunction())而不需要选中DOM元素((‘selector’).myfunction())。

    $.extend({
    sayHello: function(name) {
    console.log(‘Hello,’ + (name ? name : ‘Dude’) + ‘!’);
    }
    })
    $.sayHello(); //调用
    $.sayHello(‘test’); //带参调用
    第二种方法:运用面向对象的思维方式,在jquery的原型上扩展方法。这就要用到 $.fn.extend({})这个方法了。

    ;(function($,window,document,undefined){ //用一个自调用匿名函数把插架代码包裹起来,防止代码污染
    $.fn.插件名称 = function (options) {
    var defaults = { //defaults 使我们设置的默认参数。
    Event : “click”, //触发响应事件
    msg : “Holle word!” //显示内容
    };
    var options = $.extend(defaults, options); //将传入参数和默认参数合并
    var $this = $(this); //当然响应事件对象

        $this.live(options.Event, function (e) {   //功能代码部分,绑定事件
            alert(options.msg);
        });
    }
    

    })(jQuery,window,document);

    //调用插件
    $("#test").插件名称({
    Event : “click”, //触发响应事件
    msg : “测试插件!” //显示内容
    });


    作者:Cool people
    来源:CSDN
    原文:https://blog.csdn.net/weixin_39398244/article/details/81539486
    版权声明:本文为博主原创文章,转载请附上博文链接!

    展开全文
  • 找到相关源码了,虽然看不懂:static PyObject *gen_send_ex(PyGenObject *gen, PyObject *arg, int exc, int closing){PyThreadState *tstate = PyThreadState_GET();PyFrameObject *f = gen->gi_frame;...

    找到相关的源码了,虽然看不懂:

    static PyObject *

    gen_send_ex(PyGenObject *gen, PyObject *arg, int exc, int closing)

    {

    PyThreadState *tstate = PyThreadState_GET();

    PyFrameObject *f = gen->gi_frame;

    PyObject *result;

    if (gen->gi_running) {

    const char *msg = "generator already executing";

    if (PyCoro_CheckExact(gen)) {

    msg = "coroutine already executing";

    }

    else if (PyAsyncGen_CheckExact(gen)) {

    msg = "async generator already executing";

    }

    PyErr_SetString(PyExc_ValueError, msg);

    return NULL;

    }

    if (f == NULL || f->f_stacktop == NULL) {

    if (PyCoro_CheckExact(gen) && !closing) {

    /* `gen` is an exhausted coroutine: raise an error,

    except when called from gen_close(), which should

    always be a silent method. */

    PyErr_SetString(

    PyExc_RuntimeError,

    "cannot reuse already awaited coroutine");

    }

    else if (arg && !exc) {

    /* `gen` is an exhausted generator:

    only set exception if called from send(). */

    if (PyAsyncGen_CheckExact(gen)) {

    PyErr_SetNone(PyExc_StopAsyncIteration);

    }

    else {

    PyErr_SetNone(PyExc_StopIteration);

    }

    }

    return NULL;

    }

    if (f->f_lasti == -1) {

    if (arg && arg != Py_None) {

    const char *msg = "can't send non-None value to a "

    "just-started generator";

    if (PyCoro_CheckExact(gen)) {

    msg = NON_INIT_CORO_MSG;

    }

    else if (PyAsyncGen_CheckExact(gen)) {

    msg = "can't send non-None value to a "

    "just-started async generator";

    }

    PyErr_SetString(PyExc_TypeError, msg);

    return NULL;

    }

    } else {

    /* Push arg onto the frame's value stack */

    result = arg ? arg : Py_None;

    Py_INCREF(result);

    *(f->f_stacktop++) = result;

    }

    /* Generators always return to their most recent caller, not

    * necessarily their creator. */

    Py_XINCREF(tstate->frame);

    assert(f->f_back == NULL);

    f->f_back = tstate->frame;

    gen->gi_running = 1;

    gen->gi_exc_state.previous_item = tstate->exc_info;

    tstate->exc_info = &gen->gi_exc_state;

    result = PyEval_EvalFrameEx(f, exc);

    tstate->exc_info = gen->gi_exc_state.previous_item;

    gen->gi_exc_state.previous_item = NULL;

    gen->gi_running = 0;

    /* Don't keep the reference to f_back any longer than necessary. It

    * may keep a chain of frames alive or it could create a reference

    * cycle. */

    assert(f->f_back == tstate->frame);

    Py_CLEAR(f->f_back);

    /* If the generator just returned (as opposed to yielding), signal

    * that the generator is exhausted. */

    if (result && f->f_stacktop == NULL) {

    if (result == Py_None) {

    /* Delay exception instantiation if we can */

    if (PyAsyncGen_CheckExact(gen)) {

    PyErr_SetNone(PyExc_StopAsyncIteration);

    }

    else {

    PyErr_SetNone(PyExc_StopIteration);

    }

    }

    else {

    /* Async generators cannot return anything but None */

    assert(!PyAsyncGen_CheckExact(gen));

    _PyGen_SetStopIterationValue(result);

    }

    Py_CLEAR(result);

    }

    else if (!result && PyErr_ExceptionMatches(PyExc_StopIteration)) {

    const char *msg = "generator raised StopIteration";

    if (PyCoro_CheckExact(gen)) {

    msg = "coroutine raised StopIteration";

    }

    else if PyAsyncGen_CheckExact(gen) {

    msg = "async generator raised StopIteration";

    }

    _PyErr_FormatFromCause(PyExc_RuntimeError, "%s", msg);

    }

    else if (!result && PyAsyncGen_CheckExact(gen) &&

    PyErr_ExceptionMatches(PyExc_StopAsyncIteration))

    {

    /* code in `gen` raised a StopAsyncIteration error:

    raise a RuntimeError.

    */

    const char *msg = "async generator raised StopAsyncIteration";

    _PyErr_FormatFromCause(PyExc_RuntimeError, "%s", msg);

    }

    if (!result || f->f_stacktop == NULL) {

    /* generator can't be rerun, so release the frame */

    /* first clean reference cycle through stored exception traceback */

    exc_state_clear(&gen->gi_exc_state);

    gen->gi_frame->f_gen = NULL;

    gen->gi_frame = NULL;

    Py_DECREF(f);

    }

    return result;

    }

    展开全文
  • 面向对象 面向对象与面向过程 面向过程的思想 步骤清晰简单,第一步做什么,第二步做...对于描述复杂的事物,为了从宏观上把握,从整体上合理分析,我们需要使用面向对象的思路来分析整个系统,但是,具体到微观的操作

    面向对象

    面向对象与面向过程

    面向过程的思想

    1. 步骤清晰简单,第一步做什么,第二步做什么。
    2. 面向过程是一种线性思维
    3. 面向过程适合处理一些较为简单的问题

    面向对象的思想

    1. 面向过程是一种物以类聚,分类的思维模式
    2. 它的步骤是会先将问题进行分类,对这些分类进行单独思考,最后才对某个分类下的细节进行面向过程的思索
    3. 面向过程适合处理复杂的问题,适合处理多人协作的问题

    面向过程与面向对象的关系

    • 对于描述复杂的事物,为了从宏观上把握,从整体上合理分析,我们需要使用面向对象的思路来分析整个系统,但是,具体到微观的操作,仍需要面向过程的思路来处理。面向对象与面向过程是不可分开的。

    什么是面向对象

    1. 面向对象就是面向对象编程(Object-Oriented Programming)简称:OOP。

    2. 面向对象编程的本质是:以类的方式组织代码,以对象的形式封装数据

    3. 面向对象是抽象的,将相似的东西抽取出来形成一个类

    4. 面向对象有三大特性:封装、继承、多态

    5. 从认识论角度考虑,是先有对象后有类,对象是具体的事物。类是抽象的,是对对象的抽象

    6. 从代码运行的角度考虑,是先有类后有对象。类是对象的模板

    类与对象的关系

    1. 类是一种抽象的数据类型,它是对某一类事物整体定义,但不能代表某一个具体的事物

    2. 对象是抽象概念的具体实例

    3. 类是抽象的,对象是具体的事物,类是对象的模板

      package com.oop.demo02;
      //学生类
      public class Student {
          //任何的类里面,只存在属性与方法
      
          //属性:字段
          String name;//默认初始值为null
          int age;//默认初始值为0
      
          //方法
          public void study(){
              System.out.println(this.name+"在学习");
              //this代表当前这个类
          }
      
      }
      /*
      //一个项目应该只能存在一个main方法
      public class Appliation {
          public static void main(String[] args) {
              //类是抽象的,需要实例化
              //类实例化后会返回一个自己的对象
              //xm和xh对象就是一个Student类的具体实例
              Student xm = new Student();
              Student xh = new Student();
              xh.name="小红";
              xh.age=3;
              xm.name="小明";
              xm.age=3;
              System.out.println(xm.name);
              System.out.println(xm.age);
              System.out.println(xh.name);
              System.out.println(xh.age);
          }
      }
       */
      

    创建与初始化对象

    1. 使用new关键字创建对象
    2. 创建对象的时候,除了分配内存空间之外,还会给创建的对象进行默认的初始化以及对类中构造器进行调用
    3. 构造器又称为构造方法,是在进行创建对象时必须要调用的,它有以下两个特点
      • 必须和类的名字相同
      • 必须没有返回类型,也不能写void
    package com.oop.demo02;
    
    public class Person {
        //一个类就算什么都不写,也会存在一个构造方法
        //显示的定义一个构造器
        String name;
    
        //这是一个无参构造
        /*
        1.使用new关键字,本质上就是在调用构造器
        2.构造器用来初始化值
        3.用Alt+insert可以快速生成构造器
         */
        public Person(){
           this.name="浩鑫";
            //构造器可以实例化初始值
        }
        //这是一个有参构造:一旦定义了有参构造,若需要调用无参构造,无参构造必须显示定义
        public Person(String name){
            this.name=name;
        }
    
    }
    /*
    package com.oop.demo02;
    
    //一个项目应该只能存在一个main方法
    public class Appliation {
        public static void main(String[] args) {
            //new 实例化一个对象
            Person person = new Person();
            Person person1 = new Person("Andy");
            System.out.println(person.name);
            System.out.println(person1.name);
    
    
        }
    }
    
    
     */
    
    展开全文
  • 类和对象的含义

    2020-07-21 17:58:40
    什么是类 类可以理解为类别,具备某些共同特征实体集合,它一种抽象数据类型,它对所具有相同特征实体抽象。 例如 人类,鸟类等。 类创建 访问修饰符 class 类名 { 类成员 } /// <summary> //...

    什么是类
    类可以理解为类别,是具备某些共同特征的实体的集合,它是一种抽象的数据类型,它是对所具有相同特征实体的抽象。
    例如 人类,鸟类等。
    类的创建
    访问修饰符 class 类名 { 类成员 }

    /// <summary>
    /// 人类
    /// </summary>
    class Person
    {    
         public string name;//姓名    
         public int age;//年龄   
         /// <summary>    
         /// 聊天    
         /// </summary>    
         public void Chat()   
         {
             Console.WriteLine("我是" + name + ",你愁啥?!");    
         }
    } 
    

    类中包含有字段,和方法。
    如果想调用类中的方法和字段,与实例化一个对象
    Person person =new Person();
    然后:
    对字段的调用

    ​ person.name = “王小虎”;

    对方法的调用

    ​ person.Chat();
    使用 . 方法就可以获取到

    对象

    什么是对象
    对象是类的实体,万物皆对象。
    创建对象
    类名 对象名=new 类名();
    调用上面的类创建对象:

    Person  person=new Person();
    

    这样就创建了一个对象,然后就可以给创建额对象添加属性。方法见上方对字段和属性的调用。
    字段和方法详情在另一篇博客。

    展开全文
  • 什么是对象对象:独立性、功能性、交互性万物皆对象,均继承于Object类OOP:面向对象编程,本质含义在于复用代码,在较大规模或复杂项目中有用,提高写作产量面向对象和面向过程对比编程实例面向过程程序解决...
  • 对象的本质:对象分配的一块内存,有足够的空间去表示它们所代表的值。—— 《Learning Python》或者说:一块内存空间,拥有特定的值,支持特定类型的相关操作2.对象的特点:Python中,对象具有三要素:标识...
  • java学习心得——面向对象的含义

    千次阅读 2015-03-06 12:17:50
    上大学时,有一门公共课,名字叫做面向对象...首先,我们要了解面向对象,要知道与面向对象对应的是什么,不面向对象的话,它是面向哪里呢? 答案是面向过程。一些基础编程语言比如C,就是面向过程的。 那面向过程和面
  • 运行时多态就是覆盖,就是子类方法覆盖父类方法。使用父类引用指向子类对象,再调用某一父类中方法时,不同子类会表现出不同结果。 运行时多态性提供了更大灵活性,因为所有事情都在运行时得到解决。 ...
  • 8.1 面向对象编程的含义  前面介绍的编程方法称为函数(或过程)化编程,常常会导致所谓的单一应用程序,即所有的功能都包含在几个代码模块中(常常一个代码模块)。 而使用OOP技术,常常要使用许多代码模块,每个...
  • 文档的结构如下: { "_id" : ObjectId("57302832d4c6025e3e44b1bc"), ... "accountInfos" : [ ...这样我就能对子文档中的数组进行插入操作,我想问的问题就是accountInfos.$.portfolios中的$的含义和作用是什么
  • 面向对象编程的四大特性及其含义 ...首先来说说面向对象的含义。 OOP(object oriented programming),面向对象的编程。学习面向对象之前还必须普及一个概念,就是面向过程,一般的学院派毕业的程序员,接...
  •  一 HibernateJDBC轻量级的对象封装,它一个独立的对象持久层框架,和App  Server,和EJB没有什么必然联系。Hibernate可以用在任何JDBC可以使用场合,例如Java应用程序数据库访问代码,DAO接口  ...
  • 低耦合, 高内聚的含义是什么

    千次阅读 2018-09-12 17:36:18
    高内聚,低耦合, 软件工程中的概念, 判断设计好坏的标准, 主要面向对象的设计, 主要看类的内聚性是否高, 耦合度是否低 高内聚 内聚就是一个模块内各个元素彼此结合的紧密程度, 高内聚就是一个模块内各个...
  • Java中关键字final修饰变量、方法、类分别表示什么含义? 先看一个简单介绍 修饰对象 解释说明 备注 类 无子类,不可以被继承,更不可能被重写。 final类中方法默认final 方法 方法不能...
  • 运行时多态:当同一个引用变量(父类引用)指向...使用父类引用指向子类对象,再调用某一父类中方法时,不同子类会表现出不同结果。 作用:运行时多态性提供了更大灵活性,因为所有事情都在运行时得到解决。 ...
  • 面向对象在js里有两bai个层次的含义,第一种会使用面向对象函数;第二种构造面向对象函数。 js也面向对象中的一种写法,不过相对于java,js一种弱数据类型,并不严格意义上的面向对象。但是jq就是使用面向...
  • --- 属无含义码 根据国家标准对代码种类划分 代码按其功能分为有含义码和无含义码 有含义除对编码对象起标识作用外 还具有其他特定含义的代码 如公民身份证代码就属于有含义码 无含义对编码对象只起标识...
  • 1.父类引用指向子类对象,掉用方法子类方法 //父类 class A { void fun() { System.out.println(“I am A”); } } //A子类B class B extends A { void fun() { System.out.println(“I...
  • 面向对象阶段最重要的知识点:面向对象的三大特性继承(组合)封装多态继承(灵魂三拷问)什么是继承?继承指的定义类的方法,新定义的类称之为子类或者派生类子类继承的类叫做父类,也叫基类/超类继承的特性:子类...
  •  定义的含义:所谓定义,就是创建(编译器)一个对象,为这个对象分配一块内存空间并取名,也就是我们平常所说的变量名或对象名,一旦这个名字和这块内存空间匹配,那么在定义的这个对象或变量的生命周期中,所创建...
  •  众所周知面向对象的三个特性:封装性、继承性、多态性。这几个特性的具体含义我等会会班门弄斧讲一下含义,下面,请允许我先用C++面向对象思维将设计模式中常用的简单工厂模式写一边,相信这三个特性不言而喻。 ...
  • 书中说对象和类的实例的含义相同。 那么怎么完成实例化呢。我们创建一个对象需要对它初始化数据。能够有这一作用的是什么呢?——构造函数。所以就有了 Car mycar= new Car(); 当我们自己定义了与类同名的有参构造...
  • 也听说过Python面向对象的编程语言,下面,融跃小编为大家详细介绍一下Python语言的面向对象。面向对象编程在面向过程编程的基础上发展来的,它比面向过程编程具有更强的灵活性和扩展性。面向对象编程程序员...
  • 面向对象到底是什么呢?他与传统的设计有什么不同呢?这是维基百科里给出我们答案:   面向对象程序设计可以看作一种在程序中包含各种独立而又互相调用的对象的思想,这与传统的思想刚好相反:传统的程序设计...
  • 1. 什么是类(1),类作用是什么(2),类和对象之间关系(3) (1) 类是对事物一种抽象定义,将抽象之后特征和行为有机结合便构成了类,类是具有共同特征和行为一类事物统称。 (2)类定义完毕后,不能...
  • 众所周知面向对象的三个特性:封装性、继承性、多态性。这几个特性的具体含义我等会会班门弄斧讲一下含义,下面,请允许我先用C++面向对象思维将设计模式中最常用的简单工厂模式写一边,相信这三个特性不言而喻。...
  • Is:检查对象是否与给定类型兼容。... 如果所提供表达式非空,并且所提供的对象可以强制转换为所提供类型而不会导致引发异常,则 is 表达式计算结果将 true。 如果已知表达式始终true或始终false,则
  • Undefined、Null、NaN的含义是什么

    千次阅读 2012-02-21 13:57:04
    Null: 类型只有一个值,即null, 表示尚未存在的对象,这个引用类型变量中保存地址为空,即尚未指向任何有效对象 Undefined:类型只有一个值,即undefined,声明变量未初始化,变量默认值就是undefined ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,726
精华内容 1,090
关键字:

对象的含义是什么